C++类

Cautiousnut

2022-08-31

C++

学习笔记

类

1. 类的特性

1.1 类类型

概述

每个类定义了唯一的类型，跟他们的内部成员没有关系。

可以把类名作为类型的名称使用，直接指向类类型；也可以将类名跟在关键字class或struct后面

class A{};

A item1;					//默认初始化A类型的对象
class A item1;				//等价的声明

类的声明

类可以声明但不定义，这种声明有时也成为前向声明。类声明向程序中引入了类名字并且指明它是一种类类型

class A;

声明之后定义之前的类类型是不完全类型，因为不知道它所包含的成员

不完全类型只能用于以下情况

定义指向这种类型的指针或引用
声明（但不能定义）以不完全类型为参数或者返回类型的函数
静态成员

1.2 this指针

基本原理

#include<iostream>
class A{
private:
    int a = 1;
public:
    int test(){
        return a;
    }
};
int main(){
    A obj;
    obj.test();
    return 0;
}

上述例子中，对象obj调用test函数。当我们调用成员函数时，实际上实在替相应的对象调用它。上述调用中，test函数返回a变量时，实际上返回的是obj.a。

成员函数通过一个名为this的隐式的参数来获取调用它的对象，当使用对象调用成员函数时，会用该对象的地址初始化this指针，并在类内部隐式的使用this指针访问类内成员

this形参是隐式定义的，并且是一个常量指针（指针本身是常量）。可以按照如下方式理解this及函数调用

A*const this;					//A类对应的this指针，常量指针
int A::test(A*const this){		//test函数声明和定义的等价形式
    return this->a;	
}
A::test(&obj);					//obj.test()，函数调用的等价形式

const成员函数

默认情况下this为常量指针，没有底层const资格，因此不能把this绑定到一个常量对象上（具有底层const资格），这使得常量对象无法调用对应类中的成员函数。此时便可以使用const成员函数

const成员函数可以将this指针的隐式定义从原来的A*const this修改为const A*const this，即为将this声明为常量指针和常量指针。当成员函数内不改变this所指向的对象时，就可以使用const成员函数

const成员函数的格式即为将const放置在函数的参数列表之后，const成员函数又称为常量成员函数

class A{
private:
    int a = 1;
public:
    int t1() const{			//此时，函数无法对对象进行修改
        return a;			//this的类型为const A*const this
    }
    int t2() const;
};
int A::t2() const{			//声明和定义时都必须有const
    return 1;
}

返回this的函数

成员函数可以以引用或者指针的形式返回this所指的对象或者this本身

//返回引用
A& test(){
    return *this;
}
//返回指针
A* test(){
    return this;
}

1.3 成员函数和内联函数

定义在类内的成员函数是自动inline的（注意是定义，不是声明）

可以显式的在类的内部使用inline修饰函数声明或者在类的外部使用inline修饰函数定义来将成员函数显式的设置为内联函数，当然也可以同时。最好在函数定义处说明inline

class A{
    inline int t1(){					//类内inline
        return 0;
    }
    inline int t2();					//类外inline
    inline int t3();					//内外都有inline
};
int A::t2(){
    return 1;
}
inline int A::t3(){
    return 2;
}

inline成员函数必须与相应的类定义在同一个头文件中，因为要进行展开

1.4 可变数据成员

在任何情况下都可修改的类数据成员，永远不会是const，即使是在const成员函数、const对象等情况下。

使用mutable关键字将数据成员声明为可变数据成员

class A{
public:
    void modify() const;
private:
    mutable int a = 0;
};
void A::modify() const{
    ++a;								//a是可修改的
}

1.5 类内初始值

C++11标准规定，可以为类内数据成员提供一个类内初始值，用于初始化

类内初始值或者放在花括号里，或者放在等号右边，不能使用圆括号

class A{
    int a{1};							//列表初始化，直接初始化
    int b = {1};						//列表初始化，拷贝初始化
    int c = 1;							//等号右边，拷贝初始化
    int d(1);							//报错
};

2. 特殊成员函数

2.1 构造函数

构造函数用于类对象的初始化，在对象被创建时会自动被调用执行。必须是public访问权限

构造函数具有以下基本特点

函数名和类名相同
没有返回类型和返回值
一个类可以包含多个构造函数，类似普通函数的重载
不能被声明为const成员函数，因为对象构造过程中可修改

默认构造函数

没有任何参数或者所有参数都有默认值的构造函数称为默认构造函数，默认构造函数用于控制类的默认初始化过程

编译器会为没有显式定义构造函数的类隐式的定义一个默认构造函数，称为合成的默认构造函数

合成的默认构造函数按照如下规则初始化类数据成员

如果类内定义数据成员时给出了初始值，则使用此初始值进行初始化
否则，对该成员执行默认初始化

默认构造函数（包括初始值列表）中没有初始化的成员也按照上述方式进行初始化

注意

类中必须有一个默认构造函数（包括合成的默认构造函数）
只有类没有声明任何构造函数时，编译器才会自动生成默认构造函数

含有内置类型或者复合类型成员的类应该在类的内部初始化这些成员（类内初始值）或者自定义构造函数。因为此时合成的默认构造函数如果使用默认初始化会导致这些成员的值未定义

class A{
private:
    int a;
    int b;
public:
    void print(){
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
    }
};
int main(){
    A obj;
    obj.print();					
    return 0;
}

当类内包含其他类类型的成员时，无法生成默认的构造函数，此时必须显式提供构造函数

默认构造函数的作用

默认构造函数在对象被默认初始化和值初始化时被自动执行

默认初始化的发生情况

块作用域内定义非静态变量和数组时没有给出初始值
1
2
class A{};
A item1; //调用A的默认构造函数

类本身含有类类型成员且使用合成的默认构造函数

class A{};
class B{
  A item1;  			//B使用合成的默认构造函数时会调用A的默认构造函数
};

类类型成员没有在构造函数初始值列表中显式的初始化

class A{};
class B{
    A item1;
    B(){}				//B调用构造函数时会调用A的默认构造函数
}

值初始化的发生情况

数组初始化的过程中提供的初始值少于数组的大小

class A{
public:
    A(){
        cout << "默认构造函数" << endl;
    }
};
int main(){
    A a[2] = {};		//执行两次默认构造函数
    return 0;
}

不使用初始值定义局部静态变量

int count(){
    static int num;		//num=0，内置类型值初始化为0
    return ++num;
}

class A{
public:
    A(){
        cout << "默认构造函数" << endl;
    }
};
int main(){
    static A a;			//调用默认构造函数进行初始化
    return 0;
}

书写形如T()的表达式显式的请求值初始化（容器初始化只提供数量而没有提供初始值？）

构造函数初始值列表

//类内
class A{
public:
    int a;  
    int b[3];
    int &c;
    A(int num):a(1),b{1,2,3},c(num){}
};
//类外
class A{
public:
    int a;  
    int b[3];
    int &c;
    A(int num);
};
A::A(int num):a(1),b{1,2,3},c(num){}

使用冒号开始构造函数初始值列表，每个名字后紧跟括号括起来的(或者花括号)成员初始值，不同成员的初始化通过逗号分隔开

初始化和赋值

//初始化
class A{
private:
    int a = 1;
    double b = 1.0;
};

//初始化
class A{
private:
    int a;
    double b;
public:
    A():a(1),b(1.0){}
};

上述两种方式都为变量的初始化操作，下面这种为变量的赋值操作。构造函数体执行之前会对没有进行初始化（没有在定义时初始化也没有在构造函数初始值列表中初始化）的成员执行默认初始化操作

//赋值
class A{
private:
    int a;
    double b;
public:
    A(){
        a = 1;
        b = 1.0;
    }
};

即类内定义变量时给出初始值和使用构造函数初始值列表都是进行初始化，而在构造函数函数体中的操作则为赋值

对于const类型、引用类型和未提供默认构造函数的类类型等，初始化和赋值必须严格区分，否则会引发错误

class A{
private:
    const int a;
    int&b;
public:
    A(int c){					//错误，无法进行赋值操作
        a = 1;
        b = c;
    }
    A(int c):a(1),b(c){}		//正确，进行初始化
};

成员初始化顺序

构造函数初始值列表的优先级高于定义时初始化，如果一个变量在初始值列表和定义时进行了初始化，则以初始值列表为准

构造函数初始值列表只说明初始化成员的值，而不影响初始化的顺序。成员的初始化顺序由其在类中定义的顺序决定，先定义的先被初始化，以此类推

class A{
public:
    int a;
    int b;
    //此语句会出错
    A(int c):b(c),a(b){}			//先初始化a，再初始化b
};

委托构造函数

构造函数可以使用同一类中的其他构造函数执行自己的初始化过程，即把它自己的一些职责委托给了其他构造函数。这种构造函数即为委托构造函数

委托构造函数的语法类似构造函数初始值列表，在函数参数列表之后使用:后接想要委托的构造函数，其后再接函数体。委托构造函数会在函数体执行之前执行受委托的构造函数，然后再执行自己的函数体

class A{
private:    
    int a;
    int b;
public:
    A(int a,int b):a(a),b(b){}		//构造函数1
    A():A(1,2){}					//委托构造函数1进行初始化
    A(int c):A(){}					//委托默认构造函数进行初始化
};

隐式的类类型转换

如果类的构造函数只接受一个实参，则实际上定义了一个从实参类型转换为此类类型的转换机制，此机制就自动调用此构造函数完成。

隐式类类型转换的触发条件为

类含有只接收一个实参（假设为T类型）的构造函数（必须接收一个实参，可以有其他默认实参）
在需要使用类类型变量的地方，直接使用T类型变量替代
只能进行一步转换，即必须是T类型，而不能是其他可以转换为T类型的类型

class A{
private:
    int num;
public:
    A(){
        cout << "默认构造函数" << endl;
    }
    A(int n):num(n){
        cout << "构造函数" << endl;
    }
    void test(const A&a){
        cout << a.num << endl;
    }
};
int main(){
    A a;					//调用默认构造函数进行初始化
    a.test(1);				//int类型转换为A类型，调用A(int)构造函数获取临时A对象传入test
    return 0;
}
/*执行结果
*	默认构造函数
*	构造函数
*	1
*/

进行隐式类类型转换时，编译器自动调用相应的构造函数创建临时的类类型对象传入当前语句或函数。当前语句或函数使用完成后，临时对象会被销毁

可以通过将构造函数声明为explicit来阻止隐式的类类型转换

class A{
private:
    int num;
public:
    A(){
        cout << "默认构造函数" << endl;
    }
    explicit A(int n,int b = 1):num(n){	//阻止隐式的类类型转换
        cout << "构造函数" << endl;
    }
    void test(const A&a){
        cout << a.num << endl;
    }
};
int main(){
    A a;
    a.test(1);					//此时会报错
    return 0;
}

explicit关键字只对接收一个实参（除默认实参外）的构造函数有用，并且只能用于类内的构造函数声明中，在类外的构造函数定义时不能使用

使用explicit关键字修饰的构造函数只能用于直接初始化，不能用于拷贝形式的初始化过程

1
2
3

//使用上一代码中的定义
A a(1);						//正确，直接初始化
A a = 1;					//错误，拷贝初始化

使用explicit关键字修饰的构造函数不会被用于隐式的类型转换过程，但是还是可以显式的调用来强制转换类型

1
2
3

A a;
a.test(A(1));				//正确，显式转换
a.test(static_cast<A>(1));	//正确，显式转换

2.2 析构函数

2.3 拷贝构造函数

2.4 拷贝赋值构造函数

2.5 移动析构函数

2.6 移动赋值析构函数

3. 访问控制与封装

3.1 访问权限控制

C++使用访问说明符加强类的封装性，一个类可包含多个访问说明符，一种访问说明符可出现多次

访问说明符：

public：说明符后的成员在整个程序内可被访问，用于提供接口
private：说明符后的成员只能被所在类的成员函数访问，用于封装实现细节

#include<iostream>
class Sales_data{
//public后的为开放接口，此处为构造函数和一些功能函数
public:
    Sales_data() = default;
    Sales_data(const std::string &s,unsigned n,double p)
        :bookNo(s),units_sold(n),revenue(p*n){}
    Sales_data(std::istream&);
    std::string isbn() const {
        return bookNo;
    }
    Sales_data &combine(const Sales_data&);
//private后的为类内的成员变量和函数，不能被外部调用
private:
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
    double avg_price() const{
        return units_sold ? revenue/units_sold : 0;
    }
};

类的关键字也会影响类的访问控制权限。类关键字有两个，struct和class。二者都可用于类的定义，且只有默认的访问权限不同，其余完全一致。这两个关键字所影响的访问权限为类中第一个访问说明符之前定义的成员。

struct关键字定义的类，在定义第一个访问说明符之前的成员是public的

class关键字定义的类，在定义第一个访问说明符之前的成员是private的

#include<iostream>
class Test1{
    int a = 1;
};
struct Test2{
    int a = 1;
};
int main(){
    Test1 t1;
    Test2 t2;
    std::cout << t1.a << std::endl;			//无法访问，是private
    std::cout << t2.a << std::endl;			//可以访问，是public
    return 0;
}

3.2 友元

类可以允许其他类或者函数访问它的私有成员，只需要将其他类或者函数使用friend关键字设置为其友元。

友元声明必须在类的内部，并且位置不限，不受所在区域访问控制级别的约束和限制

友元声明最好在类定义开始或者结束的位置统一声明，这样代码更加简明

友元函数

将需要定义为友元函数的函数在要访问的类中加上friend关键字重新声明即可

类外函数为友元函数

#include<iostream>
class Sales_data{
public:
    Sales_data() = default;
    Sales_data(const std::string &s,unsigned n,double p)
        :bookNo(s),units_sold(n),revenue(p*n){}
    Sales_data(std::istream&);
    std::string isbn() const {
        return bookNo;
    }
    Sales_data &combine(const Sales_data&);
private:
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
    double avg_price() const{
        return units_sold ? revenue/units_sold : 0;
    }
};
//此时此函数会报错，因为不是类的成员函数，但是访问了类的私有成员变量
std::istream &read(std::istream &is,Sales_data &item){
    double price = 0;
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price*item.units_sold;
    return is;
}

#include<iostream>
class Sales_data{

//将函数声明为友元函数，read此时可以访问类的私有成员
friend std::istream &read(std::istream&,Sales_data&);
    
public:
    Sales_data() = default;
    Sales_data(const std::string &s,unsigned n,double p)
        :bookNo(s),units_sold(n),revenue(p*n){}
    Sales_data(std::istream&);
    std::string isbn() const {
        return bookNo;
    }
    Sales_data &combine(const Sales_data&);
private:
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
    double avg_price() const{
        return units_sold ? revenue/units_sold : 0;
    }
};
std::istream &read(std::istream &is,Sales_data &item){
    double price = 0;
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price*item.units_sold;
    return is;
}

友元函数的声明只是指定函数的访问权限，而非真正的函数声明。相应友元函数的声明还需要在类外再进行一次，否则无法调用友元函数。通常将友元函数的类外声明和类本身放在同一个头文件中，防止无法调用的情况。

友元函数可以定义在友元声明的位置，但是友元声明不是函数声明，函数必须重新进行声明才能被正确调用

#include<iostream>
class A{
    friend void test(int a){			//友元声明
        std::cout << a << std::endl;
    }
};
void test(int);							//函数声明

类内函数为友元函数

其他类的成员函数为友元函数

在声明时明确指出成员函数属于哪个类，注意依赖关系

A类声明B类中的成员函数print为A类的友元。此时A和B的声明与定义需要按照如下顺序

定义B类，并在其中声明print函数。如果函数要用到A类，则提前声明A类
定义A类，声明对于B类中的clear函数的友元关系
定义print函数，此时print函数能够访问A的私有成员

#include<iostream>
class A;								//A类提前声明

class B{
public:
    void print(A&);						//只声明函数，不定义
};

class A{
friend void B::print(A&);				//声明友元
private:
    int a = 10;
};
void B::print(A&item){					//定义友元函数
    std::cout << item.a << std::endl;
}

重载函数的友元

重载函数本质上是不同的函数，因此如果想要将一组重载函数声明为类的友元，则需要对每一个函数分别声明

友元类

将需要定义为友元类的类在要访问的类中加上friend关键字重新声明即可。

友元类中的成员函数可以访问此类的所有成员

class Sales_data{

//将Saler类定义为Sales_data类的友元类，Saler类的成员函数可以访问Sales_data中的所有成员
friend class Saler;

public:
    Sales_data() = default;
private:
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

class Saler{
public:
    void print(Sales_data&item){
        std::cout<< item.revenue << item.units_sold << std::endl;
    }
};

友元关系无法传递，类A有友元类B，B有友元类C，则B可以访问A的所有成员，C可以访问B的所有成员，但是C不能访问A的非公有成员。

4. 类的作用域

每个类都有自己独立的作用域，在类外部访问类成员需要使用相应的运算符

对象、指针和引用访问类内成员使用.或者->两种成员访问运算符进行访问

类类型成员使用::作用域运算符进行访问，类类型成员为类内定义的函数和类型别名

在类外部定义成员

即为在类外部使用::访问类类型成员，并进行相关操作。注意，只能在类外部定义，相应的声明必须在类内部

//在外部访问类内定义的函数和类型
class A{
public:
    typedef struct {
        int a;
        int b;
    } test;
    void Test(int);
};
A::test it1;					//访问类型
void A::Test(int a){			//访问函数，此处的类作用域 包含 函数名称、参数列表和函数体
    test it2;					//作用域不包含返回值
    std::cout << a << std::endl;
}

class A{
public:
    using test = double;
    test Test(int);
};
A::test A::Test(int a){			//返回类型为类类型成员，需要使用::运算符
    std::cout << a << std::endl;
    return 1;
}

class A{
};
void A::test();					//错误，没有在类中声明
void A::test(){					//错误，没有在类中声明
    ...
}

4.1 名字查找

编译器对于类的定义分为两步处理

编译类内成员的声明
类内成员全部可见后编译函数体

因此，类中的任意成员函数可以调用类中定义的所有名字。但是注意，类内成员声明中使用的名字必须在使用前可见

类成员声明中的名字查找

对于类成员声明中的名字，编译器首先在类作用域内查找，如果找不到，则向类外层作用域中查找，以此类推，如果最终没有找到，则报错

#include<iostream>
using namespace std;

typedef double Money;
string bal;

class Account{
public:
    Money balance(){			//返回值的Money为外部定义的名字
        return bal;				//bal为内部定义的名字，不是外部的
    }
private:    
    Money bal;
};

在类中，如果一个类成员声明首先使用了外层作用域中的名字，且此名字为一种类型，则之后类中声明的同名类型不会覆盖同名外部名字，只会对其后的其他声明和定义起作用。注意此处可能产生的错误

typedef string Money;
string bal;
class Account{
public:
    Money balance(){				//此处的Money为外部定义的Money
        Money a;					//此处的Money为内部定义的Money
        return a;					//此时会出错，类型不匹配
    }
private:    
    typedef int Money;				//此处和之后的Money为内部定义的Money
    Money bal = 1;
};

最好将类型名的定义放置在类的开始处，防止可能产生的错误

类成员定义中的名字查找

类成员函数定义中使用的名字的查找过程如下

首先在成员函数内查找该名字的声明
成员函数内没有找到，则在类内进行查找，查找所有的类成员
如果类内也没有找到，则在类外（成员函数定义之前）的作用域中查找

int a = 0;
class A{
public:
    int a = 1;							//覆盖了外部的a
    void test1(int a);					
    void test2(){
        std::cout << a << std::endl;	//访问类内的a,a = 1
        std::cout << ::a << std::endl;	//使用::访问全局作用域中的a,a = 0
    }
};
int b = 2;
void A::test1(int a){
    std::cout << a << std::endl;		//a为函数内声明的局部变量，是形参
    std::cout << b << std::endl;		//b为类外作用域，函数定义之前声明的名字,b = 2;
    std::cout << c << std::endl;		//找不到c
}
int c = 3;

5. 特殊的类

5.1 聚合类

聚合类的用户可以直接访问其成员，并且具有特殊的初始化形式

聚合类需满足如下条件

所有成员的访问权限都是public
没有定义任何构造函数
没有使用类内初始值
没有基类，没有virtual函数

//典型的聚合类
struct Data{
    int a;
    double b;
}

聚合类的初始化形式比较特殊，除类通用的初始化方式，还可以使用花括号包含的成员列表进行初始化(显式初始化)，类似数组的列表初始化过程，并且规则相同。初始化的过程中类成员声明顺序和初始值列表中的顺序相对应进行初始化；如果初始值列表中的元素数量少于类的成员数量，则剩余的成员执行值初始化；初始值列表中的成员个数不能多于类中的成员数量

1 2	//初始化Data聚合类 Data val = {1,1.2}; //a = 1,b = 1.2

聚合类的显式初始化的问题

修改类成员之后，所有初始化语句都要更新
将正确初始化每个对象的每个成员的责任交给了用户

5.2 字面值常量类

字面值常量类类型属于字面值类型，可以被声明为constexpr的

字面值常量类有两种情况，符合任一种的都是字面值常量类

聚合类，且数据成员都是字面值类型
非聚合类，但满足下述要求
- 数据成员都是字面值类型
- 类必须至少含有一个constexpr构造函数
- 如果一个数据成员含有类内初始值
  - 此成员为内置类型，则初始值必须为常量表达式
  - 此成员为类类型，则初始值必须使用成员自己的constexpr构造函数
- 类必须使用析构函数的默认定义

constexpr构造函数可以有如下三种形式

=default形式
删除函数的形式
既符合构造函数的形式（无返回语句）又符合constexpr函数的形式（只能有返回语句这一种可执行语句），综合来看，即函数体无任何语句。注意：可以有构造函数初始值列表

class B{
public:
    constexpr B(){}
};
class A{
private:
    int a;						//构造函数初始值列表初始化
    double b = 1.1;				//类内初始值，常量表达式
    B c = B();					//类内初始值，constexpr构造函数，？
public:
    constexpr A():a(1){}
};
/*
*constexpr构造函数必须初始化所有成员，使用以下三种方式
* - 构造函数初始值列表
* - 类内初始值，使用常量表达式
* - 类内初始值，使用类成员自己的constexpr构造函数
*/
int main(){
    constexpr A a;				//将a声明为constexpr的，并检查其是否为字面值常量类
    return 0;
}

6. 类的静态成员

类的静态成员只和类相关联，而不是与类对象保持关联。即类的所有对象共享此静态成员

6.1 声明静态成员

类静态成员可以是public或者private的，只要在声明时加上关键字static即可。

类静态成员包括静态数据成员，静态函数成员，二者具有相似的性质，都被对象所共享，并且与类相绑定，而不是对象。因此静态成员函数不包含this指针，所以静态成员函数不能声明为const的，也不能直接访问类内的非静态成员（隐式采用this指针访问）

class A{
public:
    static int b;			//静态数据成员
    static int test(){		//静态函数成员
        return b;
    }
};

6.2 使用静态成员

静态成员的访问

类的静态成员有如下几种访问方式

作用域运算符
1
2
int c = A::b;
A::test();

类的对象、引用或指针

A t1;
A *t2 = &t1;
A &t3 = t1;
int a = t1.b;
t2->test();
t3.test();

直接访问，类内部函数和表达式可以直接访问静态成员

class A{
public:
    static int a;
    static int test(){return 1;}
    int b = a*2;					//直接访问
    int test2(){					//直接访问
        test();
        return a;
    }
};

静态成员的特殊应用场景

静态成员可以是不完全类型，甚至是它所属的类类型。因为静态成员在类内只声明，不定义和初始化

class A{
private:
    static A a;							//只声明，不定义和初始化
};
A A::a = A();

静态成员可以作为默认实参，静态成员在对象创建之前就可用，且存在于整个对象的生命周期中

class A{
public:
    int test(int = a);					//作为默认实参
private:
    static int a;
};
int A::a = 2;
int A::test(int b){
    return b;
}

6.3 定义和初始化静态成员

静态成员函数

类的静态成员函数可以在类内定义，也可以类似其他成员函数在类外进行定义。在类外定义静态成员函数时不用重复static关键字。

class A{
    static int test();
};
int A::test(){							//不重复static关键字
    return 1;
}

静态数据成员

静态数据成员不属于任何一个类对象，因此也不应该使用构造函数初始化。一般在类的外部定义和初始化所有的静态数据成员。static关键字同样只能用于类内数据成员的声明，而不能用于类外数据成员的定义和初始化

class A{
    static int a;						//类内声明，没有定义
    int b;								//声明、定义，但没有初始化
};
int A::a = 1;							//类外定义和初始化

类的静态成员也可以在类内声明和初始化，此时要求此成员必须是constexpr的，并且初始值必须是常量表达式。在类内初始化的静态成员，通常也需要在类外进行定义

class A{
    static constexpr int a = 1;			//类内声明和初始化
};
constexpr int A::a;						//类外定义