语源科技BlogJava- 通关旅

C++体会 -- 静态数据成员

softgamer — Sat, 10 Feb 2007 01:12:00 GMT

   静态数据成员很像是全局变量，但static数据成员有类作用域，静态成员可以是public,private或protected.
   静态数据成员在文件范围内必须进行一次初始化。类的public静态成员可以通过类的任何对象访问，也可以用二元作用域分辨符通过类名进行访问。类的private和protected 静态成员必须通过类的public成员函数或类的友元访问。即使类没有对象，但仍然有静态成员。类没有对象时，要想访问public静态类成员，只需在成员数据名前加上类名和二元作用域分辨符(::).要在类没有对象时访问private或protected 静态类成员，则需要提供一个public静态成员函数，并在调用函数时在函数名前面加上类名和二元作用域分辨符。

#File Test.h
#ifndef TEST_H
#define TEST_H

class Test
{
   public:
         Test( const char * , const char * );
         ~Test();
         const char *GetFstString() const;
         const char *GetLstString() const;

         static int GetCount();

private:
         char * strFst;
         char * strLst;

         static int count;

};

#endif
---------------------------------------------------------------------------------
#File Test.cpp
#include

using std::cout;
using std::endl;

#include
#include
#include "Test.h"

int Test::count = 0;

int Test::GetCount() { return count ; }

Test::Test( const char * sFst, const char * sLst )
{
   strFst = new char[ strlen( sFst ) + 1 ];
   assert( strFst != 0 );
   strcpy( strFst, sFst );

   strLst = new char[ strlen( sLst ) + 1 ];
   assert( strLst != 0 );
   strcpy( strLst, sLst );

   count++; // inc static count

   cout << " Test cons for " << strFst
        << " " << strLst << " called. " << endl;
}

Test::~Test()
{
   cout << " ~Test() called for " << strFst
        << " " << strLst << endl;
   delete [] strFst;
   delete [] strLst;
   count--;
}

const char * Test::GetFstString() const
{
    return strFst;
}

const char * Test::GetLstString() const
{
    return strLst;
}

--------------------------------------------------------------------------------
#File: main.cpp
#include

using std::cout;
using std::endl;

#include "Test.h"

int main()
{
   cout << "before cons is "
        << Test::GetCount() << endl; // use class name

   Test *pTest1 = new Test( "FstTest1", "LstTest1" );
   Test *pTest2 = new Test( "FstTest2", "LstTest2" );

   cout << "after cons is "
        << pTest1->GetCount(); //using instan

   cout << "\n\nTest1: "
        << pTest1->GetFstString()
        << " " << pTest1->GetLstString()
        << "\nTest2:"
        << pTest2->GetFstString()
        << " " << pTest2->GetLstString() << "\n\n" << endl;

   delete pTest1;
   pTest1 = 0;
   delete pTest2;
   pTest2 = 0;

   cout << "num after deletion is "
        << Test::GetCount() << endl;

   return 0;

}
-------------------------------------------------------------------------------------------

Result:
before cons is 0
Test cons for FstTest1 LstTest1 called.
Test cons for FstTest2 LstTest2 called.
after cons is 2

Test1: FstTest1 LstTest1
Test2:FstTest2 LstTest2

~Test() called for FstTest1 LstTest1
~Test() called for FstTest2 LstTest2
num after deletion is 0

   Test类在没有对象时，仍然可以引用count成员，但是只能通过调用静态成员函数GetCount()完成.
   没有实例化的对象，一定是用类名调用Test::GetCount(),如果有实例化的对象，则可以用pTest1->GetCount()
调用。我们公司明确规定，所有静态成员函数只能调用类名句柄，不能调用对象句柄，我觉得这样很好。

   还有一点，如果成员函数不访问非静态数据成员和成员函数，可以将成员函数声明为静态，与非静态成员函数不同的是，静态成员函数没有this指针，因为静态类数据成员和成员函数是独立于类对象而存才的。

   关于断言(assert) , assert类宏在cassert头文件中定义。用于测试条件值，注意assert不运行任何析构函数即可中止程序执行. assert不一定要在调试完成后删除，只需在程序文件开头(通常可以在编译器选项中指定)插入语句
#define NDEBUG

softgamer 2007-02-10 09:12 发表评论

C++体会 -- 初始化类的常量数据成员

softgamer — Fri, 09 Feb 2007 14:19:00 GMT

如果你想初始化一个类中的常量数据成员，只能用一种方法，在类的构造函数后加一个":",然后初始化那些常量数据成员，
以逗号分割。

#include

using std::cout;
using std::endl;

class Test
{
public:
    Test(int i = 0, int j = 1 );
    void addon() { count += idx; }
    void print() const;
private:
    int count;
    const int idx;
   const int idy;
};

Test::Test( int i, int j )
:idx( j, i ), idy( j, j )
{
   count = j;
}

void Test::print() const
{
   cout << "count= " << count
        <<", idx = " << idx
        <<", idy = " << idy
        << endl;
}

int main()
{
    Test Test1( 20, 7 );
    cout << "Before doing addon: ";
    Test1.print();
    for ( int k = 0; k < 3; k++ )
    {
       Test1.addon();
       cout << "After addon " << k + 1 << ":";
       Test1.print();
    }
    return 0;
}

result:
Before doing addon: count= 7, idx = 20, idy = 7
After addon 1:count= 27, idx = 20, idy = 7
After addon 2:count= 47, idx = 20, idy = 7
After addon 3:count= 67, idx = 20, idy = 7

softgamer 2007-02-09 22:19 发表评论

向诸葛亮老师学习十堂课

softgamer — Wed, 07 Feb 2007 02:37:00 GMT

     也发一篇灌水文章，它对我帮助很大。不是我写的，是朋友发给我的。我也加了自己的一些理解

     诸葛亮54岁时写给他8岁儿子诸葛瞻的《诫子书》，只用了短短八十六字，但是对于为学做人有精简而且具体的忠告。一千八百多年前的智慧，在今天的科技时代，仍然有非常好的参考价值。以前听人说：“真正的智慧，可以超越时空，历久常新。”初听不知所以，现在觉得所言甚是。让我们一起向诸葛亮老师学习十堂课，在变局中安身立命，在逆境中找到力量。
　　《诫子书》
　　夫君子之行，靜以修身，儉以養德；非澹泊無以明志，非寧靜無以致遠。夫學須靜也，才須學也；非學無以廣才，非志無以成學。怠慢則不能勵精，險躁則不能冶性。年與時馳，意與歲去，遂成枯落，多不接世。悲守窮廬，將復何及！

　　第一课：宁静的力量
　　“静以修身”、“非宁静无以致远”、“学须静也”。诸葛亮忠告孩子宁静才能够修养身心，静思反省。不能够静下来，则不可以有效的计划未来，而且学习的首要条件，就是有宁静的环境。现代人大多数终日忙碌，你是否应在忙乱中静下来，反思人生方向？

　第二课：节俭的力量
　　“俭以养德”。诸葛亮忠告孩子要节俭，以培养自己的德行。审慎理财，量入为出，不但可以摆脱负债的困扰，更可以过着纪律的简朴生活，不会成为物质的奴隶。在鼓励消费的文明社会，你有没有想过节俭的好处呢？

　　第三课：计划的力量
　　“非澹泊无以明志”、“非宁静无以致远”。诸葛亮忠告孩子要计划人生，不要事事讲求名利，才能够了解自己的志向，要静下来，才能够细心计划将来。面对未来，你有理想吗？你有使命感吗？你有自己的价值观吗？

　　第四课：学习的力量
　　“夫学须静也”、“才须学也”。诸葛亮忠告孩子宁静的环境对学习大有帮助，当然配合专注的平静心境，就更加事半功倍。诸葛亮不是天才论的信徒，他相信才能是学习的结果。你是没有全心全力的学习？你是否相信努力才有成就呢？

　　第五课：增值的力量
　　“非学无以广才”、“非志无以成学”。诸葛亮忠告孩子要增值先要立志，不愿意努力学习，就不能够增加自己的才干。但学习的过程中，决心和毅力非常重要，因为缺乏了意志力，就会半途而废。你有没有想过，一鼓作气的人多，坚持到底的人少的道理呢？

　　第六课：速度的力量
　　“怠慢则不能励精”。诸葛亮忠告孩子凡事拖延就不能够快速的掌握要点。计算机时代是十倍速的时代，样样事情讲求效率，想不到一千八百多年前的智慧，也一样不谋而合。快人一步，理想就能实现。你有没有想过，有更多时间去修正及改善，以达成你的人生目标呢？

　　第七课：性格的力量
　　“险躁则不能冶性”。诸葛亮忠告孩子太过急躁就不能够陶冶性情。心理学家说：“思想影响行为，行为影响习惯，习惯影响性格，性格影响命运。”诸葛亮明白生命中要作出种种平衡，要励精，也要冶性。你要提升自己性格的品质吗？

　　第八课：时间的力量
　　“年与时驰”、“意与岁去”。诸葛亮忠告孩子时光飞逝，意志力又会随着时间消磨，少壮不努力，老大徒伤悲，时间管理是个现代人的观念，细心想一想，时间不可以被管理，每天二十四小时，不多也不少，惟有管理自己，善用每分每秒。请你想一想，你有蹉跎岁月吗？

　　第九课：想象的力量
　　“遂成枯落”、“多不接世”、“悲守穷庐”、“将复何及”。诸葛亮忠告孩子时光飞逝，当自己变得和世界脱节，才悲叹蹉跎岁月，也于事无补。要懂得居安思危，才能够临危不乱。想象力比知识更有力量。你有没有从大处着想，小处着手，脚踏实地，规划自己的人生呢？

　　第十课：精简的力量
　　以上诸葛亮写给儿子的一封信，只用了短短八十六字，精简地传递了具体的讯息。我相信精简的表达源于清晰的思想，长篇大论的内容，容易令人生厌，精简沟通更有效果。你懂得言之有物地精简沟通吗？

　　从以上的十堂课之中，你能够找到一点启发吗？请你百忙之中静下来，用下面的题目向你的人生提问，在改变中不断改善。
　　不要问：自己得到些什么？应该问：自己付出过什么？
　　不要问：自己的地位如何？应该问：自己的心地如何？

softgamer 2007-02-07 10:37 发表评论

与管理器共舞 --- 世纪弹跳球（第二天）

softgamer — Tue, 06 Feb 2007 14:15:00 GMT

构建游戏，其实就是构建你的管理器，你的梦工场。

对于这款游戏，我会设计一些管理器类，
他们分别是：总管理类，总更新和渲染

它的下面是：

小球管理类，负责小球的更新和渲染

砖块管理类，负责砖块的更新和渲染

宝物管理类，负责宝物的更新和渲染

。。。。。。。。。

当总管理类更新或渲染时，依次调用各个管理子类的更新或渲染，这样一些具体的东西可以通过同样的管理接口运作，而上层管理者也不用具体的管下级如何运作。
其中的一些细节是:
管理类部分,
    举一个例子，对于不同类型的砖块来说，他们属于一个砖块基类，并由这个砖块基类派生，创建自己的属性，然后再向砖块管理器注册，每增加一种类型的砖块就向管理者注册，当管理器创建此种类型的砖块时，实际就是调用这些子类的接口并创建它们。
   这样，我们就隐约看见了一个公司的运作，他们有总管理者，部门管理者和员工，管理者们是核心，员工是扩展部分，具体包括各种砖块。

资源管理部分，
很多朋友愿意把资源一次性载入，好处是，节省运行时间，方便管理等。坏处是程序初始运行时间长，内存消耗太大，很显然，你不可能同时使用所有资源，一些不用的资源，也驻留在内存里，等待调用，对于系统的有效性来讲，实在有些不划算。
   实时载入资源好处是内存使用很有效，但是频繁读写硬盘，程序运行时间延迟突出，使程序运行有时很不连贯。因此我们要具体情况具体分析，要给资源分级，哪些一次性载入，哪些是实时读写。

碰撞检测部分，

目前使用广泛的是使用矩形框来进行粗略的碰撞检测。

几种主要的碰撞:

小球与平台，按照角度，速度，加速度定出轨迹运动

小球与砖块，删除砖块（重要的是从内存中删除），

小球与宝物，更改小球的相关属性，删除宝物（重要的是从内存中删除）。

小球与墙壁，按照角度，速度，加速度定出轨迹运动

砖块与砖块，一些会按照角度，速度，加速度定出轨迹运动，一些不予理会

碰撞管理只用一个管理器完成，只是要提供不同的接口和容器。、

检测小球与砖块，或宝物发生碰撞时，可能是一对多，也可能是多对多。这个可以在小球管理器内放置一个指针，用来指示当前正在判断的砖块。进行检测时，就把这个指针指向的砖块传递给砖块管理器进行检测。然后改变这个指针。直到指针回到容器头部。

属性资源的管理

当然全部由外部资源属性文件读取，包括，小球，砖块，宝物，背景等等各个方面的属性。完全静态读取，好处是当物品被创建时，读入属性值，如果已经初始化，就使用属性值。

目前总体框架，先想到这里。大体是这样了，具体的还有很多，毕竟管理的资源多，逻辑也相对复杂。

softgamer 2007-02-06 22:15 发表评论

今天的工作日志。。。。

softgamer — Tue, 06 Feb 2007 09:59:00 GMT

由于工作的关系，从今天起开始编写FPGA驱动程序，使用的是NIOSII开发环境，以前总觉得FPGA很神秘，今天看来和所有的C环境一样简单，很快就做出了HDLC中断的通讯驱动和SPI驱动程序，真的要感谢前辈们辛苦的工作。当然FPGA硬件的设计方面还是有很多值得回味的，但软件方面实在是很索然无味，希望做FPGA的同志们别骂我，我只是今天才做 FPGA，是新的不能在新的新手了。

现在开始画弹跳球的UML框架了，不会很复杂，简洁一直是我追求的目标。

softgamer 2007-02-06 17:59 发表评论

把机械手装上 --- 世纪弹跳球（第一天续）

softgamer — Mon, 05 Feb 2007 13:27:00 GMT

   玩了三个多小时游戏，居然没死一次，我不住的在想，快死吧，可是过了一关，又紧张的玩下去了，看来我的眼睛和手配合的愈来愈快了。
大致总结了一下这款游戏的内容。

1。主体环节（除GUI等）包括：主角平台，小球（大，小），小球子弹，各种砖块（粗粗统计一下有30多种，其中特殊砖块19种），宝物（18种），各种特效（7种），关卡，关卡中的各种景物（12 种）
   2。主角运动分两部分，平台的运动，小球的运动，平台按照左右平行运动，小球按照碰撞轨迹运动
   3。小球子弹向上运动，没有AI，仅是向上垂直运动，我在考虑是不是加一个宝物，给子弹一些AI能力吧，嘿嘿
   4。看来最累的工作在砖块的运动了，包括：
      4。1 静止
      4。2 平行运动
      4。3 圆周运动
      4。4 上下运动
      4。5 曲线运动
      4。6 贝塞尔大曲线运动
      又分个体，整体，混合随机运动

5。各种特效，包括粒子系统。我想在特效上应该很漂亮。

6。各种宝物，现在的实现状态是，爆炸产生或碰撞，向下漂浮，然后消失。

7。关卡背景，景物不止一层。是多层。这就需要为每一个景物，设置一个层次值。（哪一种游戏都跑不了）

8。各种需要实现的特效，包括：

8。1 小球撞击墙壁

8。2 小球撞击砖块爆炸

8。3 砖块的各种特效

8。4 小球飞行的各种特效

8。5 背景随机的动画特效

更多的特性现在也许还没有玩到，持续添加中。。。

设计策划上，会用到的方式

1．尽可能多的属性由脚本文件（XML文件）来实现

2．尽可能的实现对象模块化，插件化。

3．资源处理上做到脚本化。这是肯定的了，这么多物品，没有脚本管理，那就是灾难。

明天继续。。。。。

softgamer 2007-02-05 21:27 发表评论

开始要写新游戏了--- 世纪弹跳球（第一天）

softgamer — Mon, 05 Feb 2007 07:20:00 GMT

这几天看朋友玩弹跳球，打算克隆这款游戏，当然还是免费让大家玩。除了继续写一些我使用C++的体会，我一有空就构思一下这款游戏的实现方式，这款游戏比较复杂，比我克隆的任何一款游戏都复杂。

相信大家都玩过弹跳球，几年前，我也玩过，不过这次的更刺激，音效更逼真，图像更精美。

在设计方面，严格按照软件工程的设计模式开发，后两天打算贴出UML的图，以做规范流程设计。估计时间总共用3周。（没算其他的事情）。

公司的工作也很繁重，我写驱动程序写了8年，写3D引擎写了3年，还没看到这样的人（这两天拿到一个芯片，老板要我2周写出芯片的架构，他疯了吧）。

我也疯了。

前两天，想写个卷轴的游戏，但当我拿到美术资源，太多了，管理起来相当费力。这种多层地图的实时卷动，不是我一个人，一周两周完成的，还是先放下了，转而写这款游戏。因为它的资源相对简单一些。做事情还是不能太浮躁，以前脑袋一热就动了，结果做到最后很吃力。很多时候想放弃，但又咬牙，告诉自己，至少要把DEMO写完，让它能玩吧！

softgamer 2007-02-05 15:20 发表评论

C++体会 -- 引用

softgamer — Mon, 05 Feb 2007 06:23:00 GMT

引用和引用参数

   C++,其实Java 和 c 都一样, 调用函数的方法有两种

   传值调用和引用调用。

   参数传值调用时，会产生该参数值得副本并将副本传递给被调用的函数，对副本的更改不会影响调用者的原始变量值，
它的优点显而易见，，缺点是复制数据会花费较长的时间。

引用调用的优点就是避免复制大量的数据，但安全性差，因为被调用的函数会直接访问并修改调用者的数据，使用是要格外小心

#include

using std::cout;
using std::endl;

int   pbyValue( int );
void pByRef ( int & );

int main ()
{
   int x = 2;
   int z = 4;

   cout << "x= " << x << " before pByvalue \n"
       <<"Getting value by pByValue: "
       << pbyValue( x ) << endl
       << "x : " << x << " Got Value\n" <
    cout << "z= " << z << " before pBy Ref \n" << endl;

   pByRef( z );

   cout << "z : " << z << " Got Value\n" <
   return 0;

}

int pbyValue ( int a )
{
   return a *= a;
}

void pByRef( int &cRef )
{
   cRef *= cRef;
}

softgamer 2007-02-05 14:23 发表评论

C++体会 -- 内联函数

softgamer — Mon, 05 Feb 2007 03:40:00 GMT

内联函数

   C++ 提供了内联函数（inline functions ），主要用于减少函数所使用的开销，尤其对于小型函数

   函数返回类型之前的限定符inline 让编译器在适当的程序部分生成函数的副本，以避免函数调用，这样使程序中插入多个函数
代码的副本，令程序增大。而不是一个函数的副本（每次调用函数时，控制都会传到函数中）。

   对内联函数的更改都需要重新编译该函数的所有调用者，这会大大影响程序的维护，所以inline用于小型的，使用频繁的函数最好.
而且内联函数也使程序的执行时间减少，但在编译时增大了程序的长度，当然也不绝对，有时也会减小程序长度，特别是内联函数是非常小的函数时。

   题外话，使用const的目的在函数中只是保护原始实参的副本，而不是原始实参本身。

softgamer 2007-02-05 11:40 发表评论

C++体会 -- 存储类

softgamer — Mon, 05 Feb 2007 03:04:00 GMT

存储类
在C++中有5个存储类说明符，auto,register, extern mutable 和static.
存储类说明符可以分为两个存储类，"自动存储类"和"静态存储类"

auto和register用于声明自动存储类的变量，此类变量是在进入声明的块时创建的，它们只存在与块被激活的期间，当程序执行退出块时，这些变量就会被删除。

只有变量可以作为自动存储类，函数的局部变量和参数通常属于自动存储类。

     auto double x, y;

   注意：用自动存储可以节省内存，我做程序的宗旨就是简单有效的是使用内存，为了能有效的使用内存，
我都是尽量有效的规划我的资源.

   对比auto,register 只能随局部变量和函数参数一起使用。

     register int x = 1;

    关键字extern 和 static 是用于声明变量和静态存储类函数的说明符，它们存在于程序开始执行时，程序在开始时就为它们分配了初始化的存储空间，但并不意味着这些标识符可用于整个程序中，其还有作用域的约束。

softgamer 2007-02-05 11:04 发表评论