C++如何在类中定义常量成员-C++-PHP中文网

在C++类中定义常量成员需区分非静态和静态场景：非静态const成员必须在构造函数初始化列表中赋值，以确保对象创建时即完成初始化；静态常量成员则推荐使用static constexpr（C++11起），可在类内直接初始化且支持编译期求值，适用于模板参数等常量表达式场景；对于非整型或复杂类型静态常量，C++17引入inline static，允许在类内定义并初始化，避免类外重复声明，提升代码集中性与可维护性。

c++如何在类中定义常量成员

在 C++ 类中定义常量成员，这事儿说起来其实挺直接的，但背后藏着一些 C++ 特有的规则和哲学。简单来说，如果你想让每个对象都有自己一份不可变的值，那就用

const

登录后复制

关键字修饰非静态数据成员，并且务必在构造函数的初始化列表中给它赋值。而如果你需要一个所有对象共享的、类级别的常量，那就要请出

static const

登录后复制

或

static constexpr

登录后复制

了，具体用哪个，得看你希望这个常量有多“硬核”，以及它的类型是什么。

解决方案

谈到在类中定义常量成员，我们通常会遇到两种核心场景：一种是每个对象独有的常量，另一种是所有对象共享的类级别常量。这两种情况的处理方式，C++ 有着明确且合理的设计。

1. 非静态常量成员（Per-object Constants）

当你希望类中的某个数据成员在对象创建后就不可更改，并且每个对象都有自己独立的一份时，你就应该使用

const

登录后复制

关键字来修饰它。

立即学习“C++免费学习笔记（深入）”；

#include <iostream>

class Configuration {
private:
    const int version; // 这是个非静态常量成员
    const std::string name; // 字符串类型也可以

public:
    // 注意这里：非静态常量成员必须在构造函数的初始化列表中初始化
    // 在构造函数体内部赋值是行不通的，因为它们在进入函数体之前就已经被“构造”好了
    Configuration(int ver, const std::string& n) : version(ver), name(n) {
        // version = ver; // 错误：常量不能被赋值
        std::cout << "Configuration object created with version " << version 
                  << " and name '" << name << "'" << std::endl;
    }

    void printInfo() const {
        std::cout << "Current Config: Version " << version 
                  << ", Name: " << name << std::endl;
    }
};

// int main() {
//     Configuration c1(1, "Alpha");
//     Configuration c2(2, "Beta");
//     c1.printInfo(); // Output: Current Config: Version 1, Name: Alpha
//     c2.printInfo(); // Output: Current Config: Version 2, Name: Beta
//     return 0;
// }

登录后复制

这里有个关键点，也是初学者常会疑惑的地方：为什么

const int version;

登录后复制

不能在构造函数体里写

version = ver;

登录后复制

？因为

const

登录后复制

意味着一旦初始化就不能变。在 C++ 中，成员变量的初始化发生在构造函数体执行之前。如果等到函数体里才尝试赋值，那对

const

登录后复制

成员来说，它在初始化阶段就没被赋值，这显然是矛盾的。所以，通过初始化列表直接在成员构造时就赋予其值，这是唯一合法且逻辑自洽的方式。

2. 静态常量成员（Class-level Constants）

如果你需要一个常量，它不属于任何一个特定的对象，而是属于整个类，并且所有对象都共享同一个值，那么

static

登录后复制

关键字就派上用场了。结合

const

登录后复制

或

constexpr

登录后复制

，我们有几种选择。

static const

登录后复制

适用于整型或枚举类型，可以直接在类内初始化： 这种方式非常简洁，编译器通常能直接处理。

class GameSettings {
public:
    static const int MAX_PLAYERS = 4; // 整型常量，直接在类内初始化
    static const double PI_APPROX;   // 非整型或复杂类型，通常需要类外定义
};

// 对于非整型或复杂类型的 static const 成员，你需要在类外（通常是 .cpp 文件中）进行定义和初始化
// 否则会遇到链接错误，因为它们需要在某个翻译单元中有一个实际的存储位置
const double GameSettings::PI_APPROX = 3.14159;

登录后复制

这里

MAX_PLAYERS

登录后复制

是个“编译期常量”，编译器知道它的值，甚至可能直接替换掉所有使用它的地方。而

PI_APPROX

登录后复制

虽然也是

static const

登录后复制

，但因为它是

double

登录后复制

类型，通常需要在类外进行定义，给它分配实际的内存空间。

```
static constexpr
```
登录后复制
适用于所有可在编译期确定的常量：
```
constexpr
```
登录后复制
是 C++11 引入的，它比
```
const
```
登录后复制
更强调“编译期常量”的属性。如果一个值能在编译时确定，用
```
constexpr
```
登录后复制
更好，因为它允许编译器做更多优化，甚至在某些场景下能用于模板参数或数组大小。
```
static constexpr
```
登录后复制
成员必须在类内初始化。
```
class MathConstants {
public:
    static constexpr double EULER_NUMBER = 2.718281828459045; // 必须在类内初始化
    static constexpr int BUFFER_SIZE = 1024;
};
```
登录后复制
```
static constexpr
```
登录后复制
成员通常是内联的（implicitly
```
inline
```
登录后复制
），这意味着你不需要在
```
.cpp
```
登录后复制
文件中再次定义它们，这简化了代码。它们是真正意义上的编译期常量，可以用于需要常量表达式的上下文，比如
```
std::array
```
登录后复制
的大小。
C++17 引入的
```
inline static
```
登录后复制
数据成员： C++17 之后，
```
static
```
登录后复制
数据成员可以直接在类内定义并初始化，而不需要在类外再次定义。这解决了
```
static const double PI_APPROX;
```
登录后复制
这种需要类外定义的问题，让代码更集中。
```
class ModernSettings {
public:
    // C++17 之后，即使不是 constexpr，也可以用 inline static 在类内定义并初始化
    inline static const std::string APP_NAME = "MyAwesomeApp"; 
    inline static int defaultTimeout = 3000; // 甚至非const也可以
};
```
登录后复制
虽然
```
inline static
```
登录后复制
主要是为了非
```
const
```
登录后复制
的
```
static
```
登录后复制
成员可以在类内初始化，但它也适用于
```
static const
```
登录后复制
成员，让代码更加简洁。

为什么非静态常量成员必须通过初始化列表初始化？

这真的是个经典问题，尤其对刚接触 C++ 的开发者来说，很容易在这里绊一跤。核心原因在于 C++ 中“初始化”和“赋值”是两个截然不同的概念，而且它们的发生时机也不同。

百度文心百中

百度大模型语义搜索体验中心

查看详情

当我们声明一个

const

登录后复制

成员变量，比如

const int value;

登录后复制

，我们是在告诉编译器：“嘿，这个

value

登录后复制

一旦被赋予了初始值，就再也不能改了。”问题来了，这个“初始值”什么时候给？

在 C++ 对象构造过程中，成员变量的初始化发生在构造函数体执行之前。想象一下，一个对象就像一个新生的婴儿，它的“骨架”（成员变量）在它被正式“命名”（构造函数体执行）之前就已经搭好了。对于

const

登录后复制

成员，它必须在“骨架”搭建好的那一刻就拥有它的“基因”（初始值）。

如果你尝试在构造函数体内部

value = ver;

登录后复制

，那么在进入函数体之前，

value

登录后复制

实际上已经被“默认构造”或者处于未初始化状态（对于基本类型）。然后你再尝试给一个已经（可能未初始化地）存在的

const

登录后复制

成员“赋值”，这违反了

const

登录后复制

的承诺——它不能被赋值。初始化列表的作用，就是在成员变量被真正构造出来的那一刻，直接将值传递给它，确保它从诞生之初就是

const

登录后复制

的，且拥有正确的值。这就像给婴儿出生时就赋予姓名一样，而不是出生后才去改名。

所以，这不仅仅是语法规定，更是

const

登录后复制

语义在 C++ 对象生命周期中的必然体现。它保证了

const

登录后复制

成员从一开始就是不可变的。

static const

登录后复制

和

static constexpr

登录后复制

成员有什么区别？

这两个关键字都用于定义静态常量，但它们在语义强度和用途上还是有不小的差异。理解它们能帮助我们写出更高效、更安全的 C++ 代码。

```
static const
```
登录后复制
：
- 编译期常量（针对整型和枚举）：对于像
```
int
```
  登录后复制
  ,
```
char
```
  登录后复制
  ,
```
enum
```
  登录后复制
  这类整型或枚举类型，
```
static const
```
  登录后复制
  成员的值必须在编译时确定，并且可以直接在类内初始化。编译器会把这些值当作字面量来处理，通常不会为它们分配独立的内存空间，除非你取它们的地址。
- 运行时常量（针对非整型或复杂类型）：对于
```
double
```
  登录后复制
  ,
```
std::string
```
  登录后复制
  等非整型或复杂类型，
```
static const
```
  登录后复制
  成员虽然也是常量，但它的值可能在编译时无法完全确定（例如，涉及到浮点数计算或复杂对象构造），或者它需要实际的存储空间。这种情况下，你需要像
```
const double GameSettings::PI_APPROX = 3.14159;
```
  登录后复制
  那样，在类外（通常是
```
.cpp
```
  登录后复制
  文件）进行定义和初始化，为它分配内存。
- 用途：适合那些在编译期已知且不需复杂计算的常量，或者那些在运行时确定但一旦确定就不可变的值（尽管后者通常用普通
```
const
```
  登录后复制
  成员更常见）。
```
static constexpr
```
登录后复制
：
- 强制编译期常量：
```
constexpr
```
  登录后复制
  是 C++11 引入的，它的核心思想是“在编译期求值”。
```
static constexpr
```
  登录后复制
  成员必须在编译时就能确定其值，并且必须在类内初始化。这意味着它的值不能依赖于任何运行时才能确定的信息。
- 更强的编译时保证：
```
constexpr
```
  登录后复制
  提供了更强的编译时保证。它可以用于需要常量表达式的上下文，比如模板参数、
```
std::array
```
  登录后复制
  的大小、
```
case
```
  登录后复制
  语句的标签等。如果一个表达式不是
```
constexpr
```
  登录后复制
  ，那么它就不能在这些地方使用。
- 隐式
  inline
  登录后复制
  ：从 C++17 开始，
```
static constexpr
```
  登录后复制
  成员是隐式
```
inline
```
  登录后复制
  的，这意味着你不需要在
```
.cpp
```
  登录后复制
  文件中再次定义它们，这避免了 ODR (One Definition Rule) 的潜在问题，也简化了代码。
- 用途：当你需要一个绝对的、能在编译时完全确定的常量时，
```
static constexpr
```
  登录后复制
  是最佳选择。它不仅提供了常量性，还提供了编译时求值的保证，这对于性能优化和元编程非常有用。

总结一下我的看法：

static constexpr

登录后复制

可以看作是

static const

登录后复制

的一个更严格、更强大的子集。如果一个值能用

static constexpr

登录后复制

定义，那就优先使用它，因为它提供了更多的编译时检查和优化潜力。如果不能（比如它是一个运行时才能确定的复杂对象），那

static const

登录后复制

可能是你的选择，但对于非整型，别忘了在类外定义。

如何在C++17及更高版本中更优雅地定义类内常量？

C++17 确实在类内常量定义方面提供了一个相当优雅的改进，主要是通过引入

inline static

登录后复制

数据成员。这解决了之前

static

登录后复制

非

constexpr

登录后复制

成员（尤其是非整型）需要在类外定义和初始化的问题，让代码的声明和定义更加集中。

在 C++17 之前，如果你有一个

static const std::string APP_VERSION = "1.0.0";

登录后复制

这样的成员，你需要在类声明中写

static const std::string APP_VERSION;

登录后复制

，然后在

.cpp

登录后复制

文件中写

const std::string MyClass::APP_VERSION = "1.0.0";

登录后复制

。这不仅增加了代码量，也分散了信息。

C++17 引入的

inline static

登录后复制

解决了这个问题。现在，你可以直接在类定义中声明并初始化任何

static

登录后复制

数据成员，包括

static const

登录后复制

和

static constexpr

登录后复制

成员。编译器会保证它只被定义一次（通过

inline

登录后复制

语义）。

#include <iostream>
#include <string>
#include <vector>

class GlobalAppConfig {
public:
    // C++17 之前，像这样的 static const std::string 需要在类外定义
    // 现在，可以直接在类内用 inline static 定义并初始化了，非常方便
    inline static const std::string APP_NAME = "MyAwesomeApp";
    inline static const int DEFAULT_PORT = 8080; // 当然，整型 static const 以前也能在类内初始化

    // 对于更复杂的类型，比如 std::vector，以前更是麻烦，现在也行了
    inline static const std::vector<std::string> SUPPORTED_LANGS = {"en", "fr", "de"};

    // static constexpr 依然是首选，它本身就是隐式 inline 的
    static constexpr double PI = 3.1415926535;

    void printConfig() const {
        std::cout << "App Name: " << APP_NAME << std::endl;
        std::cout << "Default Port: " << DEFAULT_PORT << std::endl;
        std::cout << "Supported Languages: ";
        for (const auto& lang : SUPPORTED_LANGS) {
            std::cout << lang << " ";
        }
        std::cout << std::endl;
        std::cout << "Value of PI: " << PI << std::endl;
    }
};

// int main() {
//     GlobalAppConfig config;
//     config.printConfig();
//     // 你也可以直接通过类名访问这些常量
//     std::cout << "Direct access to APP_NAME: " << GlobalAppConfig::APP_NAME << std::endl;
//     return 0;
// }

登录后复制

这种