C++ Primer：static const与static constexpr的类内数据成员初始化（练习7.58解答）

---

1. 背景

  在C++Primer 中文版（第5版）第270页中，对静态数据成员的类内初始化作如下说明：

我们可以为静态成员提供const整数类型的类内初始值，不过要求静态成员必须是字面值常量类型的constexpr。

  上面的句子不好理解。故找到如下对应的英文版说明：

we can provide in-class initializers for static members that have const integral type and must do so for static members that are constexprs of literal type.

  如上英文的大致意思：

我们可以为const整型的静态数据成员提供类内初始值。constexprs的静态成员必须提供类内初始值。

  个人理解：

1. 算术类型包括整型和浮点型。整型包括bool、char、int、short、long等。浮点型包括float和double等（详见C++Primer第30页）。
2. const整型类型的静态数据成员（即static const的整型数据成员）可以使用类内初始值来初始化。
3. constexprs的静态成员（即static constexpr的数据成员）必须使用类内初始值来初始化。

2. 实例

2.1 static数据成员

#include <iostream>
using namespace std;
class A
{
public:
    //整型的静态成员
    static bool b;
    static char c;
    static int i;
    //浮点型的数据成员
    static float f;
    static double d;

    // static int i1 = 1;       // 错误：带有类内初始值设定项的成员必须为常量
    // static double d1 = 3.14; // 错误：带有类内初始值设定项的成员必须为常量
};

bool A::b = true;
char A::c = 'a';
int A::i = 1;
float A::f = 1.5;
double A::d = 2.5;

int main()
{
    cout << A::b << endl;
    cout << A::c << endl;
    cout << A::i << endl;
    cout << A::f << endl;
    cout << A::d << endl;
    return 0;
}

总结：

1. 一般的static数据成员只能在类内声明，在类外定义和初始化。

2.2 static const数据成员

#include <iostream>
using namespace std;
class A
{
public:
    //整型的静态成员
    static const bool b1;
    static const char c1;
    static const int i1;
    //浮点型的数据成员
    static const float f1;
    static const double d1;

    //整型的静态成员
    static const bool b2 = false;
    static const char c2 = 'b';
    static const int i2 = 2;
    //浮点型的数据成员
    // static const float f2 = 3.5;  // 错误："const float" 类型的成员不能包含类内初始值设定项
    // static const double d2 = 4.5; // 错误："const double" 类型的成员不能包含类内初始值设定项

    // char m1[i1];// 错误：i1的常量还未初始化
    char m2[i2];
};

const bool A::b1 = true;
const char A::c1 = 'a';
const int A::i1 = 1;
const float A::f1 = 1.5;
const double A::d1 = 2.5;

const bool A::b2;
const char A::c2;
const int A::i2;

int main()
{
    cout << A::b1 << endl;
    cout << A::c1 << endl;
    cout << A::i1 << endl;
    cout << A::f1 << endl;
    cout << A::d1 << endl;
    cout << "---------------------------------------" << endl;
    cout << A::b2 << endl;
    cout << A::c2 << endl;
    cout << A::i2 << endl;
    return 0;
}

总结：

1. static const数据成员可以在类内声明，在类外定义和初始化。在类内声明时，static const数据成员还未初始化，不算真正的const。
2. static const整型数据成员可以在类内声明和初始化，在类外定义。在类内声明和初始化时，static const数据成员是真正的const。
3. 若编译时static const数据成员可用它的值替代（如表示数组个数等），它可以不需要定义。若不能替代（如作为参数等），必须含有一条定义语句。建议不管是否可替代都在类外定义一次。
4. 若static const数据成员不是整型（bool、char、int、short、long等），则不能在类内初始化。

2.3 static constexpr数据成员

#include <iostream>
using namespace std;
class A
{
public:
    //整型的静态成员
    // static constexpr bool b1; // 错误：constexpr 静态数据成员声明需要类内初始值设定项
    // static constexpr char c1; // 错误：constexpr 静态数据成员声明需要类内初始值设定项
    // static constexpr int i1;  // 错误：constexpr 静态数据成员声明需要类内初始值设定项
    //浮点型的数据成员
    // static constexpr float f1;  // 错误：constexpr 静态数据成员声明需要类内初始值设定项
    // static constexpr double d1; // 错误：constexpr 静态数据成员声明需要类内初始值设定项

    //整型的静态成员
    static constexpr bool b2 = false;
    static constexpr char c2 = 'b';
    static constexpr int i2 = 2;
    //浮点型的数据成员
    static constexpr float f2 = 3.5;
    static constexpr double d2 = 4.5;

    // char m1[i1]; // 错误：i1的常量还未初始化
    char m2[i2];
};

// constexpr bool A::b1 = true;
// constexpr char A::c1 = 'a';
// constexpr int A::i1 = 1;
// constexpr float A::f1 = 1.5;
// constexpr double A::d1 = 2.5;
constexpr bool A::b2;
constexpr char A::c2;
constexpr int A::i2;
constexpr float A::f2;
constexpr double A::d2;

int main()
{
    cout << A::b2 << endl;
    cout << A::c2 << endl;
    cout << A::i2 << endl;
    cout << A::f2 << endl;
    cout << A::d2 << endl;
    return 0;
}

总结：

1. static constexpr数据成员必须在类内声明和初始化。在类内声明和初始化时，static constexpr数据成员是真正的const。
2. 若编译时static constexpr数据成员可用它的值替代（如表示数组个数等），它可以不需要定义。若不能替代（如作为参数等），必须含有一条定义语句。建议不管是否可替代都在类外定义一次。
3. 若static constexpr数据成员即使不是整型，也可进行类内初始化时。

3. 习题解析

练习7.58：下面的静态数据成员的声明和定义有错误吗？请解释原因。

#include <iostream>
#include <vector>
using namespace std;

class Example
{
public:
    static double rate = 6.5;
    static const int vecSize = 20;
    static vector<double> vec(vecSize);
};

double Example::rate;
vector<double> Example::vec;

解答：

1. 一般的static数据成员只能类内声明，类外定义和初始化。rate不是static const或static constexpr，只是一般static数据成员，不能在类内初始化。

static double rate = 6.5;
//改为
static double rate;

2. vecSize的类型是static const int，可类内初始化。vecSize仅用于表示vector容器的个数，编译时可直接用20替代，故在类外定义或者不定义都是可行的，但最好在类外定义一次以防万一。

static const int vecSize = 20; // 正确
// 最好在类外添加定义
static const int vecSize;

3. vecSize已在类内初始化，可用于表示vector的容量。vec只是一般static数据成员，不能在类内初始化。

static vector<double> vec(vecSize);
// 改为
// 类内
static vector<double> vec;
// 类外
vector<double> Example::vec(vecSize);

修改后：

#include <iostream>
#include <vector>
using namespace std;

class Example
{
public:
    static double rate;
    static const int vecSize = 20;
    static vector<double> vec;
};

double Example::rate;
static const int vecSize;
vector<double> Example::vec(vecSize);