c++ 常量(const)和静态(static)

科学的发展-只不过是读大自然写的代码

已于 2024-07-26 15:27:47 修改

阅读量1.2k

点赞数 10

分类专栏： # c++11 文章标签： c++ 静态只读 const static

于 2024-07-26 15:15:48 首次发布

本文链接：https://blog.csdn.net/xie__jin__cheng/article/details/140715938

版权

c++11 专栏收录该内容

34 篇文章 2 订阅

订阅专栏

概述和要点

1.c++ 常量

在C++中，常量是固定值的标识符，其值在程序运行期间不能更改。C++支持不同类型的常量，并且可以用不同的方式声明它们。

字面常量

字面常量是直接在代码中出现的值，例如：

int a = 10; // 这里的10就是一个字面常量

符号常量

符号常量是使用const关键字声明的常量。它们在声明时必须初始化，并且在程序的生命周期内其值不能改变。

const int MAX_VALUE = 100;

在这个例子中，MAX_VALUE是一个常量，其值被设置为100，并且不能在程序运行期间更改。

枚举常量

枚举常量是通过enum关键字声明的。它们通常用于表示一组命名的整数值。

enum Color { RED, GREEN, BLUE };

在这个例子中，RED、GREEN和BLUE都是枚举常量，它们分别代表不同的整数值（默认情况下，RED为0，GREEN为1，BLUE为2）。

预处理器宏

预处理器宏也可以用来定义常量，但它们实际上是在编译前进行文本替换，而不是真正的常量。它们使用#define指令定义。

#define PI 3.14159

在这个例子中，每当编译器遇到PI时，它都会在编译前将其替换为3.14159。

使用场景

字面常量通常用于直接赋值或计算。
符号常量用于表示程序中不会改变的值，如配置参数、最大长度等。
枚举常量用于表示一组具有特定意义的值，便于代码的阅读和维护。
预处理器宏常用于定义一些全局的配置参数或条件编译。

注意：虽然预处理器宏可以用于定义常量，但它们有一些缺点（如缺乏类型检查），因此在现代C++编程中，更推荐使用const或constexpr（C++11及以后版本）来定义常量。

2.const 的声明和定义有什么要求

在C++中，使用const关键字声明常量时，有一些规则和要求需要遵守：

初始化：const对象必须在声明时进行初始化。因为常量在初始化后其值就不能再改变，所以没有初始化的const对象是无法被赋值的。
```
const int a = 10; // 正确，初始化了  
const int b;      // 错误，没有初始化
```
类型：const可以修饰任何基本数据类型、结构体、类或其他复合类型。
作用域：const对象的作用域与其他变量相同，取决于它在哪里被声明。如果在函数内部声明，则其作用域仅限于该函数；如果在全局或命名空间范围内声明，则其作用域为整个程序。
链接性：在全局或命名空间范围内声明的const对象默认具有内部链接性，这意味着它们只在定义它们的文件内可见。如果想让const对象在其他文件中也可见，可以使用extern关键字。
```
// File: globals.h  
extern const int GLOBAL_CONST;  

// File: globals.cpp  
const int GLOBAL_CONST = 42;
```
指针与const：当使用const修饰指针时，需要注意const的位置，因为它决定了是指针本身不可变，还是指针指向的内容不可变，或者两者都不可变。
constexpr：C++11引入了constexpr关键字，它用于定义在编译时就能确定值的常量表达式。constexpr比const更严格，它要求表达式的值在编译时必须是已知的。
类中的const成员：在类中，const成员变量必须在构造函数初始化列表中初始化，因为const成员在对象生命周期内不能被修改。
非静态成员函数后面加const：这表示该函数不会修改类的成员变量（除了静态成员变量和mutable成员变量），这种函数可以称为常量成员函数。
```
class MyClass {  
public:  
    int value;  
    MyClass(int v) : value(v) {}  
    int getValue() const { return value; } // 常量成员函数  
};
```

这些是const声明和定义时的一些基本规则和要求。使用const可以提高代码的可读性和可维护性，同时也能防止程序中的意外修改，增强程序的健壮性。

3.const 可以是私有的吗

是的，const成员可以是私有的（private）。在C++类中，你可以将常量成员声明为私有，这意味着它们只能在类内部被访问，而不能从类的外部直接访问。这样做有助于封装类的内部状态，并防止外部代码直接修改这些状态。

下面是一个简单的示例，展示了如何在类中声明一个私有的const成员：

class MyClass {  
private:  
    const int privateConstMember = 10; // 私有的常量成员  
  
public:  
    MyClass() {}  
  
    // 提供一个公共的成员函数来访问私有的常量成员  
    int getPrivateConstMember() const {  
        return privateConstMember;  
    }  
};  
  
int main() {  
    MyClass obj;  
    // int value = obj.privateConstMember; // 错误！不能从外部访问私有成员  
    int value = obj.getPrivateConstMember(); // 正确，通过公共成员函数访问  
    return 0;  
}

在这个例子中，privateConstMember是一个私有的const成员变量。由于它是私有的，所以不能在类的外部直接访问它。相反，我们提供了一个公共的成员函数getPrivateConstMember()来允许外部代码间接地获取这个私有常量成员的值。

私有的const成员在类的设计中很有用，特别是当你想要确保某些值在对象的生命周期内保持不变，并且不希望这些值被外部直接访问或修改时。

4.const 可以添加静态标识符吗

是的，const可以与static结合使用，来声明静态常量。在C++中，static关键字有几种不同的用途，但当与const一起使用时，它通常指的是一个类的静态成员，这意味着该成员不属于类的任何特定实例，而是与类本身相关联。

静态常量成员在类的所有实例之间是共享的，且它们的值在程序运行期间保持不变。静态常量成员通常在类定义中声明，并在类外定义和初始化（如果它们是整数类型或枚举类型，并且它们的初始化是常量表达式，则可以在类内部初始化）。

下面是一个示例，展示了如何在类中声明和定义静态常量成员：

class MyClass {  
public:  
    // 静态常量成员声明  
    static const int StaticConstMember;  
  
    // ... 其他成员 ...  
};  
  
// 静态常量成员定义和初始化  
const int MyClass::StaticConstMember = 42;  
  
int main() {  
    // 访问静态常量成员  
    int value = MyClass::StaticConstMember;  
  
    return 0;  
}

请注意，如果静态常量成员是整型或枚举类型，并且其初始化值是一个常量表达式，则C++11及以后的版本允许在类内部进行初始化：

class MyClass {  
public:  
    // 在类内部初始化静态常量成员  
    static const int StaticConstMember = 42;  
  
    // ... 其他成员 ...  
};  
  
int main() {  
    // 访问静态常量成员  
    int value = MyClass::StaticConstMember;  
  
    return 0;  
}

然而，对于非整型或枚举类型的静态常量成员，或者当初始化值不是一个常量表达式时，你仍然需要在类外部进行定义和初始化。

静态常量成员在编译时就已经确定，它们可以用于需要常量表达式的上下文，比如数组的大小、枚举值、模板参数等。而且，由于它们是静态的，因此不会占用每个类实例的内存空间。

5.c++ static

在C++中，static关键字具有多重含义，具体取决于其上下文。以下是static在C++中的几种用法：

静态局部变量：
在函数内部，你可以声明一个静态局部变量。这样的变量只会被初始化一次，且在函数调用之间会保持其值。静态局部变量在程序执行期间只分配一次内存，且它们的生命周期会持续到程序结束。
```
void counter() {  
    static int count = 0; // 静态局部变量  
    count++;  
    std::cout << count << std::endl;  
}
```
每次调用counter函数时，count变量都会增加，而不会被重新初始化为0。

静态类成员：
在类中，static可以用来声明静态成员变量或静态成员函数。静态成员不属于类的任何特定实例，而是与类本身相关联。所有类的实例共享相同的静态成员。

class MyClass {  
public:  
    static int staticMember; // 静态成员变量  
    static void staticFunction() { /* ... */ } // 静态成员函数  
};  

int MyClass::staticMember = 0; // 静态成员变量需要在类外定义和初始化

静态全局变量和函数：
在文件作用域中，static可以用来声明静态全局变量或静态函数。这些变量和函数的作用域被限制在声明它们的文件内，这意味着它们在其他文件中是不可见的。这有助于避免全局命名空间污染和提供封装。
```
static int staticGlobalVariable = 42; // 静态全局变量  
static void staticFunction() { /* ... */ } // 静态函数
```
在类中的静态常量成员：
如前面所述，static const成员在类中声明为静态常量。如果它们是整型或枚举类型，并且初始化值是一个常量表达式，那么它们可以在类内部初始化。否则，它们需要在类外部进行定义和初始化。
```
class MyClass {  
public:  
    static const int StaticConstMember = 100; // 可以在类内初始化  
};
```

static关键字的这些用法允许程序员控制变量和函数的作用域、生命周期和可见性，从而实现更好的封装和模块化管理。在设计类和程序结构时，合理地使用static可以帮助提高代码的可读性、可维护性和重用性。

6.c++ 中，static 可以修饰类吗

在C++中，static关键字不能直接用来修饰类。static主要用于修饰类的成员（包括数据成员和成员函数），以及用于函数内部或全局作用域的变量和函数。

然而，有一种情况你可能会觉得static与类相关，那就是静态成员。静态成员是属于类而不是类的任何特定实例的。这意味着，无论创建多少个类的对象，都只有一个静态成员的副本存在。

这里是一个简单的例子来说明静态成员：

class MyClass {  
public:  
    static int count; // 静态数据成员  
    static void incrementCount() { // 静态成员函数  
        count++;  
    }  
    MyClass() {  
        incrementCount();  
    }  
};  
  
// 静态成员变量需要在类外部定义和初始化  
int MyClass::count = 0;  
  
int main() {  
    MyClass obj1;  
    MyClass obj2;  
    std::cout << MyClass::count << std::endl; // 输出 2，因为创建了两个MyClass对象  
    return 0;  
}

在这个例子中，count是MyClass的一个静态成员变量，它跟踪了MyClass对象的数量。incrementCount是一个静态成员函数，用于增加count的值。注意，静态成员变量需要在类外部进行定义和初始化。

虽然static不直接修饰类，但可以通过修饰类的成员来影响类的行为。如果你想要一个类只能有一个实例（即单例模式），你可以通过结合使用私有静态成员变量和公共静态成员函数来实现这一点。

总的来说，static在C++中不能直接修饰类，但可以修饰类的成员，以提供类级别的变量和行为。

7.c++ 静态成员，可以在头文件中初始化吗

在C++中，静态成员变量通常不能在头文件中直接初始化。静态成员变量是属于类的，而不是类的某个具体实例，因此它们需要在类外进行定义和初始化。

通常的做法是在头文件中声明静态成员变量，并在一个源文件中定义和初始化它。这样做是为了避免重复定义的问题，因为头文件可能会被多个源文件包含。

例如，你有一个类MyClass，它在头文件中声明了一个静态成员变量staticMember：

// MyClass.h  
class MyClass {  
public:  
    static int staticMember; // 声明静态成员变量  
    // ...  
};

然后，在一个源文件中，你需要定义并初始化这个静态成员变量：

// MyClass.cpp  
#include "MyClass.h"  
  
int MyClass::staticMember = 0; // 定义并初始化静态成员变量

这样做确保了staticMember只在一个地方被定义和初始化，避免了链接时的重复定义错误。

然而，有一个特例是对于静态常量整型或枚举类型的成员，如果它们的初始化值是一个常量表达式，那么它们可以在类内部进行初始化。这种情况下，初始化是在编译时完成的，不需要在类外再次定义。例如：

// MyClass.h  
class MyClass {  
public:  
    static const int StaticConstMember = 42; // 在类内部初始化静态常量成员  
    // ...  
};

但请注意，这种在类内部初始化的静态常量成员通常只能用于需要常量表达式的上下文（例如，数组大小、模板参数等）。如果你需要取这个静态常量成员的地址，或者它不是整型或枚举类型，你仍然需要在类外进行定义。

总的来说，除了静态常量整型或枚举成员在特定条件下可以在类内初始化外，其他静态成员变量都应该在类外的一个源文件中进行定义和初始化。

8.c++ 值类型的静态成员，可以在类外初始化吗

在C++中，值类型的静态成员（如整型、浮点型、枚举等）确实需要在类外部进行初始化，即使在类内部已经声明了它们。静态成员变量的声明通常在类定义中，但它们的定义和初始化必须在类外部完成，且只能初始化一次。

下面是一个例子：

// MyClass.h  
class MyClass {  
public:  
    static int staticIntMember; // 静态成员变量声明  
    // 其他成员...  
};  
  
// MyClass.cpp 或其他.cpp 文件  
#include "MyClass.h"  
  
int MyClass::staticIntMember = 10; // 静态成员变量初始化

在这个例子中，staticIntMember 是一个值类型的静态成员变量。它在类定义中声明，并在类外的源文件中初始化。这样的初始化是必须的，因为静态成员变量不属于类的任何对象实例，而是与类本身关联。因此，它们需要单独的空间来存储值，这通过在类外部定义和初始化来实现。

重要的是要确保静态成员变量的初始化只出现在一个源文件中，以避免链接时因重复定义而产生的错误。通常，这个初始化会放在实现类方法的源文件中。

总结来说，值类型的静态成员变量确实需要在类外部进行初始化。

9. c++ 值类型的静态成员，可以在类内初始化吗

在C++中，值类型的静态成员通常不能在类内部初始化，除非它们是const且其初始化值为一个常量表达式。这是C++标准的一个特例，允许在类定义中直接初始化静态常量整型或枚举类型的成员。

例如：

class MyClass {  
public:  
    static const int StaticConstInt = 42; // 可以在类内初始化，因为它是const且初始化值为常量表达式  
};

然而，对于非const的静态成员变量，或者即使是const但其初始化值不是一个常量表达式的情况，都必须在类外部进行定义和初始化。

例如，以下情况需要在类外初始化：

class MyClass {  
public:  
    static int StaticInt; // 非const静态成员，需要在类外初始化  
    static const float StaticConstFloat; // 即使是const，但因为float类型的常量表达式有限制，通常也需要在类外初始化  
};  
  
// 在类外的某个源文件中  
int MyClass::StaticInt = 0;  
const float MyClass::StaticConstFloat = 3.14f;

总的来说，除了静态常量整型或枚举成员在特定条件下可以在类内初始化外，其他值类型的静态成员变量都需要在类外部的一个源文件中进行定义和初始化。这样做是为了确保每个静态成员只有一个唯一的定义，并且分配了适当的存储空间。

10.const 修饰的变量必须声明的时候就初始化，对吗

不完全正确。const 修饰的变量通常应该在声明时进行初始化，以确保其值在程序运行期间保持不变。然而，有几种情况可以不在声明时初始化：

类成员变量：对于类的const成员变量，可以在构造函数的初始化列表中进行初始化，而不是在声明时。

class MyClass {  
public:  
    const int myConstMember;  
    MyClass(int value) : myConstMember(value) {} // 在构造函数初始化列表中初始化  
};

静态类成员：对于静态的const类成员，如果它是整型或枚举类型，并且初始化值是一个常量表达式，那么它可以在类内部初始化。否则，它需要在类外部定义并初始化。
```
class MyClass {  
public:  
    static const int StaticConstInt = 10; // 可以在类内初始化  
    static const float StaticConstFloat; // 需要在类外初始化  
};  

// 在类外的某个源文件中  
const float MyClass::StaticConstFloat = 3.14f;
```

extern 变量：如果一个const变量被声明为extern，那么它可以在其他地方定义并初始化。

// File1.cpp 或 File1.h  
extern const int myExternalConst; // 声明  

// File2.cpp  
const int myExternalConst = 42; // 定义并初始化

函数内的局部变量：在函数内部声明的const局部变量必须在声明时初始化，因为它们没有默认的构造函数或初始化列表来设置它们的值。
```
void myFunction() {  
    const int localConst = 10; // 必须在声明时初始化  
}
```

总的来说，虽然const变量通常应该在声明时初始化，但也有一些特定情况允许在稍后的时间点进行初始化，如类的构造函数初始化列表中或extern变量的定义中。不过，对于函数内的局部变量，由于它们没有构造函数或初始化列表，所以必须在声明时初始化。

11.const成员变量，可以在构造函数的初始化列表中进行初始化，是否有c++的版本限制

在C++中，对于类的const成员变量，确实可以在构造函数的初始化列表中进行初始化。这种做法并不是某个特定C++版本引入的功能，而是C++语言特性的一部分，自C++98标准以来就一直支持。

C++98、C++03、C++11、C++14、C++17以及最新的C++20标准都允许在构造函数的初始化列表中初始化const成员变量。这是因为const成员变量在对象的生命周期内其值不能改变，所以它们必须在对象构造时被初始化，并且之后不能再被修改。

下面是一个简单的例子，展示了如何在不同版本的C++中使用构造函数的初始化列表来初始化const成员变量：

class MyClass {  
public:  
    const int value;  
    MyClass(int v) : value(v) {} // 在构造函数初始化列表中初始化const成员变量  
};  
  
int main() {  
    MyClass obj(42); // 创建一个MyClass对象，并将42传递给构造函数  
    // obj.value = 43; // 这行是错误的，因为value是const，不能被修改  
    return 0;  
}

这段代码在C++98及更高版本的标准中都是有效的。尝试在构造函数体内部而不是初始化列表中初始化const成员变量将导致编译错误，因为const成员在构造函数体执行之前就必须被初始化。

因此，没有版本限制关于在构造函数的初始化列表中初始化const成员变量。这是C++语言的一个基本特性，适用于所有版本的C++标准。