Static关键字遇上继承

 

例子：

 

例二：

class A
{

public:
    static int a;
    int b;
    void printfB()
    {
        cout<<"我是父类的B"<<b<<endl;
    }
    void print()
    {
        cout<<"我是父类"<<endl;
    }
protected:

private:
};

//这句话的意思是 给静态变量初始化0
//告诉C++编译器为整个类分配 4个字节的内存空间
int A::a = 0;

class B : private A
{
public:
    
    int c;
    void print()
    {
        cout<<"我是子类"<<endl;
        cout<<a<<endl;
    }
protected:
private:
};

void main()
{
    B b1;
    b1.print();
    
    system("pause");
}

这个例子的关键是，如果没有高亮部分的   int A::a = 0;  那么编译会出错。

编译以上代码会出现“对‘A::a’未定义的引用”错误。

这是因为静态成员变量a未定义，也就是还没有分配内存，显然是不可以访问的。

 

可以通过以下几个例子更形象的说明这个问题：

//test.cpp 

#include <stdio.h> 
class A { 
    public: 
        static int a; //声明但未定义
 }; 
int main() { 
    printf("%d", A::a);
    return 0;
}   

编译以上代码会出现“对‘A::a’未定义的引用”错误。这是因为静态成员变量a未定义，也就是还没有分配内存，显然是不可以访问的。
再看如下例子：

//test.cpp 

#include <stdio.h> 
class A { 
    public: 
        static int a; //声明但未定义
 }; 
int A::a = 3; //定义了静态成员变量，同时初始化。也可以写"int A:a;"，即不给初值，同样可以通过编译
int main() { 
    printf("%d", A::a);
    return 0;
}

这样就对了，因为给a分配了内存，所以可以访问静态成员变量a了。
因为类中的静态成员变量仅仅是声明，暂时不需分配内存，所以我们甚至可以这样写代码：

//a.cpp

class B; //这里我们使用前置声明，完全不知道B是什么样子
class A {
    public:
        static B bb;//声明了一个类型为B的静态成员，在这里编译器并未给bb分配内存。
                    //因为仅仅是声明bb,所以编译器并不需要知道B是什么样子以及要给其对应的对象分配多大的空间。
                    //所以使用前置声明"class B"就可以保证编译通过。
};

对于类来说，new一个类对象不仅会分配内存，同时会调用构造函数进行初始化，所以类对象的定义和初始化总是关联在一起。

 静态成员属于全局变量，是所有实例化以后的对象所共享的，而成员的初始化你可以想象成向系统申请内存存储数据的过程，显然这种共有对象必须提前申请好，而不是由某个实例化的对象来操纵的。