【C++】const，static和static const类型成员变量声明及其初始化

1）const定义的常量在超出其作用域之后其空间会被释放，而static定义的静态常量在函数执行后不会释放其存储空间

void f1()
{
    const int x=1;
    cout<endl;
}
void f2()
{
    static int y=2;
    cout<endl;
    y++;
}
int main()
{
    f1();//1
    f1();//1  const定义的常量在超出其作用域之后其空间会被释放
    f2();//2
    f2();//3  static定义的静态常量在函数执行后不会释放其存储空间
}

2）static静态成员变量不能在类的内部初始化，在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，比如：double Account::Rate = 2.25，static关键字只能用于类定义体内部的声明中，并且在外部定义时不能标识为static

class A
{
private:

    static int x;//static成员变量只能在内部声明，定义需要放在类的外部

public:
    void f()
    {
        cout<endl;
    }
};

//error 外部定义时不能标识为static
//static int A::x=10;

int A::x=10;//在类的外部定义该static成员变量

int main()
{
    A a;
    a.f();//10
}

3）static表示的是静态的，类的静态成员函数，静态成员变量是和类相关的，而不是和类的具体对象相关的，即使没有具体对象，也能调用类的静态成员函数和静态成员变量。一般类的静态成员函数就相当于一个全局函数，只不过它的作用域限定于包含它的文件中

class A
{
public:
    static int x;
    static void test()
    {
        cout<<"test"<<endl;
    }
    void f()
    {
        cout<endl;
    }
};


int A::x=10;

int main()
{
    //即使没有具体对象，也能调用类的静态成员函数和静态成员变量
    cout<//10
    A::test();//test

    A a1;
    a1.f();//10

    A a2;
    a2.f();//10  类的静态成员变量和对象无关，只和类有关
}

4）const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数

const成员变量只在某个对象生存期内是常量，而对于整个类而言却可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同，所以不能在类的声明中初始化const数据成员，因为类的对象没有被创建时，编译器不知道const数据成员的值是什么

class A
{
private:
    //const int x=1;
    //const int y=2; //错误的做法：在这里初始化虽然语义可以通过，但是还是会被构造函数中的值覆盖
    const int x;
    const int y;
public:
    void f()
    {
        cout<" "<endl;
    }

    A(int a,int b):x(a),y(b)//通过构造函数初始化列表来初始化const成员变量，而且必须要有构造函数
    {

    };

};

int main()
{
    A a1(10,20);
    a1.f();//10 20

    A a2(11,21);
    a2.f();//11 21
}

6）const数据成员的初始化只能在类的构造函数的初始化列表中进行，要想建立在整个类中都恒定的常量，应该用类中的枚举常量实现，或者static const

class A
{
private:
    const int x;
    const int y;
public:
    void f()
    {
        cout<" "<endl;
    }
    enum{x1=100,y1=200};

    A(int a,int b):x(x1),y(y1)//通过枚举常量进行恒定初始化，传入的a和b根本没有用到
    {

    };
};

int main()
{
    A a1(10,20);
    a1.f();//100 200

    A a2(11,21);
    a2.f();//100 200
}

class A
{
private:
    const int x;
    const int y;
public:
    void f()
    {
        cout<" "<endl;
    }
    static int x2,y2;

    A(int a,int b):x(x2),y(y2)//通过static成员变量进行恒定初始化,传入的a和b也没有起到作用
    {

    };
};

int A::x2=300;
int A::y2=400;

int main()
{
    A a1(10,20);
    a1.f();//300 400

    A a2(11,21);
    a2.f();//300 400
}

7）const成员函数的主要目的是防止成员函数修改对象内容，即const成员函数不能修改成员变量的值，但是可以访问成员变量

class A
{
private:
   int x=2;
public:
    int p() const
    {
        //x=3;//error const成员函数不能修改成员变量
        return x;//但是可以访问成员变量
    }
    void f()
    {
        cout<endl;
    }

};



int main()
{
   A a1;
   cout<//2
   a1.f();//2
}

8）static成员函数的主要目的是作为类作用域的全局函数，不能访问类的非静态数据成员，因为类的静态成员函数没有this指针，这导致：1.不能直接存取类的非静态成员变量，调用非静态成员函数，2.不能被声明为虚函数(没有this指针，实现不了多态，定义为虚函数没有意义）

class A
{
public:
    int x=2;
    void f()
    {
        cout<endl;
    }
    static int p()
    {
        int k=3;
        // k=x; //error 不能直接存取非静态成员变量
        // f(); //error 不能直接调用非静态成员函数
        return k;
    }
};

int main()
{
   A a1;
   cout<//3
   a1.f();//2
}

9)类的const static或static const成员变量必须在哪里初始化？

必须在类的外部进行定义初始化

class A
{
private:
    static const int x;
    const static int y;//哪个关键字在前无所谓，x和y的含义是相同的
public:
    void f()
    {
        cout<" "<endl;
    }

};

const int A::x=300;//不能加static关键字，但是必须加const关键字
const int A::y=400;

int main()
{
    A a1;
    a1.f();//300 400

    A a2;
    a2.f();//300 400
}