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 发表评论

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: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 发表评论

C++体会 -- 类型

softgamer — Fri, 02 Feb 2007 06:04:00 GMT

我在使用C++时有一些体会，相信大家都会的。我写出来也是和大家分享一下
1。在C++中数据类型float和double.
     同类型为float的变量相比，类型为double的变量可保存的值较大且较为准确，因此我比较喜欢使用double而不是float.这里有一个重要的点要说一下：比如我们定义两个变量
     int sum = 1230;
     int score = 230;
     double avrg = 0.0f;
     如果我们用：
     avrg = sum/score;
     其中（sum/score）这个计算结果是一个整型, 因为sum和score都是整型。在这样的计算中。小数部分会
    丢失，因此C++提供了一元强制类型转换
     avrg = static_cast< double > ( sum ) / score;

    static_cast < double > (), 这位sum创建了一个临时性的浮点数副本，这就是我们说的显式转换。对比显式转换，当然就是隐式转换，例如当score 被提升为double后，开始执行浮点除法运算。
    然后我们输出
    cout << "aver is " << setprecision(2)
            <            << avrg <   setprecision(2) 是被称作参数化操作元的东西，要加一条预编译指令
   #include
   endl是一个非参数化操纵元，它不需要头文件，如果未指定精度，浮点值会采用6个精度(默认)输出。
   注意不要愚蠢的想比较两个浮点数是否相等，应该测试两个浮点数的差值的绝对值是否小于一个指定的小值。这一点在游戏的坐标跟踪中常被用到。

# include

using std::cout;
using std::cin;
using std::endl;
using std::ios;

# include

using std::setprecision;
using std::setiosflags;

int main()
{
    int score = 0;
    int sum = 0;
    int count = 0;

    double avrg;

    cout<<"enter score - to end: ";
    cin>>score;
    while ( score != -1 )
    {
        sum = sum + score;
        count = count + 1;
        cout<< "enter score , -1 to end : ";
        cin>>score;
    }

    if( count != 0 )
    {
        avrg = static_cast< double > (sum ) / count;
        cout << "avrg is " << setprecision(2)
            << setiosflags(ios::fixed | ios::showpoint )
            << avrg << endl;
    }
    else
    {    cout << " NO!!!!!";

    }
    return 0;
}

enter score - to end: 75
enter score , -1 to end : 93
enter score , -1 to end : 23
enter score , -1 to end : 98
enter score , -1 to end : 43
enter score , -1 to end : 54
enter score , -1 to end : 56
enter score , -1 to end : 2334
enter score , -1 to end : 45
enter score , -1 to end : 43
enter score , -1 to end : 454
enter score , -1 to end : 232
enter score , -1 to end : -1
avrg is 295.83

softgamer 2007-02-02 14:04 发表评论