C++学习笔记（三）：类与对象--静态成员变量与常成员函数

静态成员变量

在C++中，静态成员变量是用来实现多个对象共享数据的目的，静态成员作为特殊的成员变量，他在每次构造对象后都能保证自己的值可以被保存下不被清除。

class example_A
{
private:            //私有成员
    int a;          //成员
    int b;          //成员
public:             //公有成员
    static int t;   //静态成员函数
    void mun();
    example_A(int x , int y);//构造函数
    ~example_A();   //析构函数
protected:          //保护成员
};

值得注意的是，静态成员变量初始化必须在类外进行
具体形式为：

type class::name = value;

上面呢的这个 类中的静态成员变量的初始化方式就为

int example_A::t = 0;

静态成员变量在初始化时不需要再加 static关键字，但必须要有数据类型。初始化的具体在值由程序需要去选择，如果不做初始化，系统默认为0

这里有一点要注意，因为静态变量保存在全局区（静态区），所以拥有默认初始值0。
而动态数据区（堆、栈）则不同，变量的默认值不确定，一般都为垃圾值 。
所以在使用动态变量前都要初始化（具体变量分区规则会在之后博客介绍）

当然，不论静态变量定义成 private、protected、public 哪一种成员类型，都可以用这种方式初始化。
*
接下来做一个完整的例子来看看他的实际应用：

#include <iostream>
using namespace std;
class example_A
{
private:            //私有成员
    int a;          //成员
    int b;          //成员
public:             //公有成员
    static int t;   //静态成员函数
    void mun();
    example_A(int x , int y);    //构造函数
    ~example_A();   //析构函数
protected:          //保护成员
};

example_A::example_A(int x, int y)    //构造函数构建
{
    a = x;
    b = y;
    t++;                //静态成员操作
}
example_A::~example_A()
{
    cout << "over" << endl;
}
void example_A::mun()
{
    int c = a + b;
    cout <<"a+b="<< c << endl;
    cout << "静态常量 t=" << t << endl;
}
int example_A::t = 0; //静态成员变量初始化
int main()
{
    example_A* ex_A = new example_A(1, 2);
    cout << "ex_A调用结果：" << endl;
    ex_A->mun();
    example_A ex_B(5, 6);
    cout << "ex_B调用结果：" << endl;
    ex_B.mun();
    example_A ex_C(5, 6);
    cout << "ex_C调用结果：" << endl;
    ex_C.mun();
    delete ex_A;
    return 0;
}

运行结果：

例子可以看出，不论哪一个对象所调用的t都是那一个t，所以有了，在通过对象名字访问静态成员变量时候，所访问到的都是同一块内存，及所有对象共用同一个静态成员变量。
这样的函数在实际应用中最明显的例子就是，当我们做一个含有多个对象并且连续的信息存储时，可以用这个变量来储存对象的数量。

const常成员函数

如果我们在C++的类中，用const 修饰某一个成员函数，那么这个成员函数可以使用类中所有变量，但不能对他们的值进行修改，这种做法多用作对数据的保护，const成员函数也被成为常成员函数。
与其他函数声明不同，const成员函数需要函数头部结尾加上const关键字。

class example_A
{
private:            //私有成员
    int a;          //成员
    int b;          //成员
public:             //公有成员
    static int t;   //静态成员函数
    void mun();
    int see() const;//常成员函数
    example_A(int x , int y);    //构造函数
    ~example_A();   //析构函数
protected:          //保护成员
};

同样函数定义也不同

int  example_A::see() const
{
    return (a + b);
}

如果我们尝试用常成员函数对变量值进行更改

int  example_A::see() const
{
    a = 8;
    return (a + b);
}

编译器会对a处进行报错

最后再来区分一下 const 的位置：

• 函数开头的 const 用来修饰函数的返回值，表示返回值是 const 类型，也就是不能被修改，例如const char * getname()。
• 函数头部的结尾加上 const 表示常成员函数，这种函数只能读取成员变量的值，而不能修改成员变量的值，例如char * getname() const。