C++类的成员

1、成员变量

成员变量可以是任何类型，如基本数据类型、引用、另一个类的对象或指针、自身类的引用或指针，但不能是自身类的对象；

成员变量不能指定为auto、register、extern 存储类型。

1.1、普通成员变量

普通成员变量是属于对象的，其生命周期就是对象的生命周期，只能通过构造函数的初始化列表进行初始化,也可以在构造函数中赋值。

如果是成员变量是一个类的对象,那么只能并且必须使用初始化列表。

1.2、常成员变量(const)

常成员变量是属于对象的，其生命周期就是对象的生命周期，在这个生命周期中其值是不可改变的。

常成员变量不能在类的内部初始化，在类的内部只是声明，只能通过构造函数的初始化列表进行初始化,并且必须进行初始化。

常变量只能初始化不能赋值，所以在构造函数中赋值，或者使用自定义的成员函数赋值都是错误的。

#include <iostream>
using namespace std;

class Example
{
public:
    Example(double pi):PI(pi){}    //必须有使用初始化列表的构造函数
    double GetPi(void){return PI;}
private:
    const double PI;                //不能在类内初始化
};

int main(void)
{
    Example ex(3.1415);
    cout << ex.GetPi() <<endl;
    return 0;
}

1.3、静态成员变量(static)

静态成员变量是属于整个类的，整个类(所有类的对象中)只有一份拷贝,相当于类的全局变量(这是对于同一进程内而言, 多进程间无效)。

静态成员变量不能在类的内部初始化，在类的内部只是声明，定义必须在类外,定义时不能加上static关键字,

定义时可以指定初始值,也可以不指定,不指定时系统默认其初始值为0.

静态成员变量同样遵守publicprivateprotected限定,当静态成员变量是公有成员时可以使用下面2种方式访问,推荐使用第一种.

// Method One
类名::静态成员变量名

//Method Two
对象名.静态成员变量名

例子:

#include <iostream>
using namespace std;

class Example
{
public:
    static char chval;                      //声明
    static int GetInt(void){return ival;}
private:
    static int ival;                        //声明
};
char Example::chval = 'A';    //定义(指定初始值)
int Example::ival;            //定义(未指定初始值) 相当于 int Example::ival = 0;

int main(void)
{
    Example ex;
    cout << ex.GetInt() << endl;         //未初始化时,静态变量被默认初始化为0;

    cout << ex.chval << endl;            //通过对象访问
    Example::chval = 'B';
    cout << Example::chval << endl;      //通过类名访问

    return 0;
}

1.4、静态常量成员变量(const static)

通过前面介绍的常成员变量和静态成员变量 ,我们知道常成员变量在对象的生命周期中恒不变，静态成员变量在整个类中全局可变。

现在想要定义一个成员变量在整个类中不可变，应该怎样定义呢？

就是将常成员变量和静态成员变量结合起来，使用const static 或者 static const定义变量，注意2者没有区别。当然使用enum定义也是很好的方法。

常静态成员变量有2种初始化的方式，1种是在类内(声明时)初始化，另一种是在类外初始化，类外初始化时要加const限定不能加static限定。

另外,需要注意一点静态常量成员变量分为整型和非整型, 非整形情况下g++与vs是不同的,g++允许非整形静态常量类内初始化,vs不允许.

class Example
{
private:
    //整型
    const static char ch = 'a';
    const static short sht = 1;
    const static long  lng = 2;
    const static int a = 10; //类内初始化
    static const int b; //等价于 const static int b；
    //非整型
    const static float c = 1.1; //注意:这种写法在vs中是编译不过的,但是g++可以
    static const double d;
};
const int Example::b = 20;    //类外初始化,一定要加const限定
const double Example::d = 2.2;

1.5、总结

1.5.1、成员变量的生命周期

成员变量的种类	生命周期
普通成员变量	同对象
常成员变量	同对象，其值不可变
静态成员变量	整个类
常静态成员变量	整个类，其值不可变

1.5.2、类中成员变量的初始化方式

成员变量的种类	初始化方式
普通成员变量	构造函数参数列表
常成员变量	构造函数参数列表
静态成员变量	类外
常静态成员变量	类内和类外

2、成员函数

2.1、普通成员函数

普通成员函数可以访问该类的所有成员变量和成员函数。

2.2、常成员函数(const)

将函数设置为常成员函数,可以禁止成员函数修改数据成员。

设置的方法是在函数的参数列表后面加上const,注意类内声明和类外定义都要加const限定。

class Example
{
public:
    char GetChar(void)const //函数中不能修改成员变量
    {
        return ch;
    }
    void SetInt(int a)const;

private:
    char ch;
    int i;
};
void Example::SetInt(int a)const //类外定义时也要加const
{
//        i = a;                //ERROR:函数中不能修改成员变量
}

2.3、静态成员函数(staitc)

静态成员函数是属于整个类的，它只能访问该类的静态成员变量和其他静态成员函数。

静态成员函数同样遵守publicprivateprotected限定,当静态成员函数是公有成员时可以使用下面2种方式访问,推荐使用第一种.

// Method One
类名::静态成员函数名

//Method Two
对象名.静态成员函数名

例子:

class Example
{
public:
    static double db;

    static void InitChar(void){ch = 0;}
    static void InitInt(void){i = 0;}
    static void InitData(void);
    void InitData2(void);
private:
    static char ch;
    static int i;
    float ft;

};
double Example::db = 3.1415;
char Example::ch = 'A';
int Example::i = 5;

void Example::InitData(void) //类外定义,不能加static限定
{
    InitChar(); //访问静态成员函数
    InitInt();  //访问静态成员函数
    db = 0;     //访问静态成员变量
}
void Example::InitData2(void) //普通成员函数能访问所有的成员
{
    InitData(); //访问静态成员函数
    ft = 0;     //访问普通成员变量
    db = 0;     //访问静态成员变量
}

2.4、构造函数

http://www.cnblogs.com/LubinLew/p/Cpp-ConstructorFunction.html

2.5、析构函数

http://www.cnblogs.com/LubinLew/p/Cpp-DeconstructorFunction.html