(7)C++ 常量

本文详细介绍了C++中的常量,包括整数、浮点数、布尔、字符和字符串常量。还讨论了使用#define预处理器和const关键字定义常量的差异,如类型检查、编译器处理方式、存储方式、作用域和可取消性。并提供实例展示const常量的使用和限制。


常量是 固定值,在程序执行期间不会改变。这些固定的值,又叫做 字面量

常量可以是任何的基本数据类型,可分为整型数字浮点数字字符字符串和布尔值

常量就像是常规的变量,只不过常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。

前缀指定基数:0x 或 0X 表示十六进制,0 表示八进制,不带前缀则默认表示十进制。

整数常量也可以带一个后缀,后缀是 U 和 L 的组合,U 表示无符号整数(unsigned),L 表示长整数(long)。后缀可以是大写,也可以是小写,U 和 L 的顺序任意。

下面列举几个整数常量的实例:

212合法的
215u合法的
0xFeeL合法的
078非法的:8 不是八进制的数字
032UU非法的:不能重复后缀

以下是各种类型的整数常量的实例:

85十进制
0213八进制
0x4b十六进制
30整数
30u无符号整数
30l长整数
30ul无符号长整数

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时,必须包含整数部分、小数部分,或同时包含两者。当使用指数形式表示时, 必须包含小数点、指数,或同时包含两者。带符号的指数是用 e 或 E 引入的

下面列举几个浮点常量的实例:

3.14159合法的
314159E-5L合法的
510E非法的:不完整的指数
210f非法的:没有小数或指数
.e55非法的:缺少整数或分数

布尔常量

布尔常量共有两个,它们都是标准的 C++ 关键字:

true 值代表真。
false 值代表假。

我们不应把 true 的值看成 1,把 false 的值看成 0。

字符常量

字符常量是括在单引号中

如果常量以 L(仅当大写时)开头,则表示它是一个宽字符常量(例如 L’x’),此时它必须存储在 wchar_t 类型的变量中。

否则,它就是一个窄字符常量(例如 ‘x’),此时它可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符(例如 ‘x’)、一个转义序列(例如 ‘\t’),或一个通用的字符(例如 ‘\u02C0’)。

在 C++ 中,有一些特定的字符,当它们前面有反斜杠时,它们就具有特殊的含义,被用来表示如换行符(\n)或制表符(\t)等。下表列出了一些这样的转义序列码:

转义序列含义
\\ 字符
’ 字符
"" 字符
?? 字符
\a警报铃声
\b退格键
\f换页符
\n换行符
\r回车
\t水平制表符
\v垂直制表符
\ooo一到三位的八进制数
\xhh . . .一个或多个数字的十六进制数

下面的实例显示了一些转义序列字符:

实例

#include <iostream>
using namespace std;
 
int main()
{
   cout << "Hello\tWorld\n\n";
   return 0;
}

当上面的代码被编译和执行时,它会产生下列结果:

Hello   World

字符串常量

字符串字面值或常量是括在双引号 “” 中的。一个字符串包含类似于字符常量的字符:普通的字符、转义序列和通用的字符。

您可以使用空格做分隔符,把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

定义常量

在 C++ 中,有两种简单的定义常量的方式:

使用 #define 预处理器。
使用 const 关键字。

const 和 define 定义常量时,两个数的范围不同。

#include<cstdio>
using namespace std;
const int  maxn=1e+10;
int main()
{
    printf("%d",maxn);
    return 0;
}

然后输出是:

2147483647

如果用 define 定义的话:

#include<cstdio>
#define maxn 1e+10
using namespace std;
int main()
{
    printf("%d",maxn);
    return 0;
}

输出是:

536870912

但是,如果将输出的 %d 改为 %lld 的话,输出为:

4756540486875873280

那么,可以思考一下,如果将 const 的数据也改成 longlong 的话,输出为:

10000000000

刚好为我们想要的那个答案。

数据的范围还有输出的格式很重要!!!

使用 #define 预处理器定义常量

预处理 #define 变量定义值以后,不能用分号,否则就会计算错误,但是程序不会报错。

#define age  12
#define age1 10

#define age2  12;
#define age3 10;

 

int main()
{
   int dd  ; 
   dd = age + age1;
   cout  << "值=" << dd << endl; //值22
   dd = age2 + age3;
   cout  << "值=" << dd << endl; //值12
    return 0;  
}预处理 #define 变量定义值以后,不能用分号,否则就会计算错误,但是程序不会报错。

形式:

#define identifier value

具体请看下面的实例:

#include <iostream>
using namespace std;
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
 
   int area;  
   
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

当上面的代码被编译和执行时,它会产生下列结果:

50

const 关键字

组成

const是constant的简写,只要一个变量前面用const来修饰,就意味着该变量里的数据可以被访问,不能被修改。

也就是说const意味着只读(readonly)。

规则

const离谁近,谁就不能被修改;

const限定符限定以后是不可以改变的,所以在定义时必须赋初始值,要不然是错误的,除非这个变量是用extern修饰的外部变量。 例如:

const int A=10;       //正确。
const int A;          //错误,没有赋初始值。
extern const int A;   //正确,使用extern的外部变量。

本质

const在谁后面谁就不可以修改,const在最前面则将其后移一位,二者等效。

作用

为给读你代码的人传达非常有用的信息,声明一个参数为常量是为了告诉用户这个参数的应用目的;

通过给优化器一些附加信息,使关键字const也许能产生更紧凑的代码;

合理使用关键字const可以使编译器很自然的保护那些不希望被修改的参数,防止无意的代码修改,可以减少bug的出现;

应用

欲阻止一个变量被改变,可使用const,在定义该const变量时,需先初始化,以后就没有机会改变他了;

对指针而言,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const;

在一个函数声明中,const可以修饰形参表明他是一个输入参数,在函数内部不可以改变其值;

对于类的成员函数,有时候必须指定其为const类型,表明其是一个常函数,不能修改类的成员变量;

对于类的成员函数,有时候必须指定其返回值为const类型,以使得其返回值不为“左值”。

可以使用 const 前缀声明指定类型的常量,如下所示:

const type variable = value;

具体请看下面的实例:

实例

#include <iostream>
using namespace std;
 
int main()
{
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = '\n';
   int area;  
   
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

当上面的代码被编译和执行时,它会产生下列结果:

50

请注意,把常量定义为大写字母形式,是一个很好的编程实践。

定义成 const 后的常量,程序对其中只能读不能修改。

以下程序是错误的,因为开头就已经固定了常量,便不能再对其进行赋值:

#include <iostream>
using namespace std;
int main()
{
    const double pi;                      //圆周率的值用pi表示
    pi=3.14159265;
    cout<<"圆周率的近似值是"<<pi<<endl;
    return 0;
}

下面给出正确的赋值方法:

#include <iostream>
using namespace std;
int main()
{
    const double pi=3.141592;            //圆周率的值用pi表示
    cout<<"圆周率的近似值是"<<pi<<endl;
    return 0;
}

宏定义 #define 和常量 const 的区别

类型和安全检查不同

宏定义是字符替换,没有数据类型的区别,同时这种替换没有类型安全检查,可能产生边际效应等错误;

const常量是常量的声明,有类型区别,需要在编译阶段进行类型检查

编译器处理不同

宏定义是一个"编译时"概念,在预处理阶段展开,不能对宏定义进行调试,生命周期结束与编译时期;

const常量是一个"运行时"概念,在程序运行使用,类似于一个只读行数据

存储方式不同

宏定义是直接替换,不会分配内存,存储与程序的代码段中;

const常量需要进行内存分配,存储与程序的数据段中

定义域不同
void f1 ()
{
    #define N 12
    const int n 12;
}
void f2 ()
{
    cout<<N <<endl; //正确,N已经定义过,不受定义域限制
    cout<<n <<endl; //错误,n定义域只在f1函数中
}
定义后能否取消

宏定义可以通过#undef来使之前的宏定义失效

const常量定义后将在定义域内永久有效

void f1()
{
  #define N 12
  const int n = 12;

  #undef N //取消宏定义后,即使在f1函数中,N也无效了
  #define N 21//取消后可以重新定义
}
是否可以做函数参数

宏定义不能作为参数传递给函数

const常量可以在函数的参数列表中出现

const char*, char const*的区别

Bjarne 在他的 The C++ Programming Language 里面给出过一个助记的方法: 把一个声明从右向左读。

char  * const cp; ( * 读成 pointer to ) 
cp is a const pointer to char 

const char * p; 
p is a pointer to const char; 

char const * p;

同上因为 C++ 里面没有 const* 的运算符,所以 const 只能属于前面的类型。

详情请看: https://www.runoob.com/w3cnote/const-char.html.

实例

常量实例:

已知半径,求圆的周长和面积。

#include<iostream>   
using namespace std;

#define PI 3.14

int main()
{
    float radius = 10.0;
    float area = PI * radius * radius;
    float circumference = 2 * PI * radius;
    cout << "area is "<<area <<", circumference is "<< circumference<<endl;
    return 0;
}

总结

角度1 定义常量

就定义常量说的话, const 定义的常数是变量 也带类型, #define 定义的只是个常数 不带类型。

角度2 起作用的阶段

就起作用的阶段而言,#define 是在编译的预处理阶段起作用,而 const 是在 编译、运行的时候起作用。

角度3 起作用的方式

就起作用的方式而言,#define 只是简单的字符串替换,没有类型检查。而 const 有对应的数据类型,是要进行判断的,可以避免一些低级的错误。 正因为 define 只是简单的字符串替换会导致边界效应,具体举例可以参考下面代码:

#define N 2+3     // 我们预想的 N 值是 5,我们这样使用 
Ndouble a = N/2;  // 我们预想的  a 的值是 2.5,可实际上 a 的值是 3.5

角度4 就空间占用而言

例如:

#define PI 3.14     //预处理后 占用代码段空间
const float PI=3.14;    // 本质上还是一个 float,占用数据段空间

角度5:代码调试的方便程度

从代码调试的方便程度而言, const 常量可以进行调试的,#define 是不能进行调试的,因为在预编译阶段就已经替换掉了

角度6 是否可以再定义的角度

从是否可以再定义的角度而言, const 不足的地方,是与生俱来的,const 不能重定义,而 #define 可以通过 #undef 取消某个符号的定义,再重新定义。

<think>我们正在讨论C++中的常量表达式。根据用户需求,需要解释常量表达式的定义、特点和使用方法。结合之前提供的引用内容,我们可以总结如下: ### 定义 常量表达式(constant expression)是指在编译期间就可以计算出结果的表达式。它的值在程序运行前就已确定,且不会改变。例如: - 字面量:`42`, `'a'`, `true` - 由常量表达式组成的运算:`20 * 4 + 8` - 用常量表达式初始化的`const`变量(在C++11之前)或`constexpr`变量(C++11起) ### 特点 1. **编译时计算**:值在编译阶段确定,不占用运行时资源。 2. **类型限制**:只能是字面类型(literal type),包括算术类型、引用、指针以及满足特定条件的类类型等。 3. **严格约束**: - 对于`constexpr`函数(C++11引入): - 函数体必须只包含一条`return`语句(C++14放宽此限制)。 - 所有参数和返回值必须是字面类型。 - 函数体中不能有未初始化的变量、不能有`goto`或非字面类型的变量定义等(C++14起允许局部变量和循环等)。 - 对于`constexpr`变量: - 必须由常量表达式初始化。 ### 使用方法 1. **定义常量**: ```cpp constexpr int size = 10; // 正确:字面量是常量表达式 constexpr double pi = 3.14159; // 正确 ``` 2. **定义数组大小**: ```cpp int arr[size]; // 正确:size是常量表达式 ``` 3. **模板非类型参数**: ```cpp template<int N> struct Array { int data[N]; }; Array<size> arr; // 正确 ``` 4. **`constexpr`函数**: ```cpp constexpr int factorial(int n) { return (n <= 1) ? 1 : n * factorial(n-1); } constexpr int fact5 = factorial(5); // 编译时计算,结果为120 ``` 5. **条件编译(C++17起)**: ```cpp if constexpr (sizeof(int) == 4) { // 仅在int为4字节时编译此代码块 } ``` ### 注意事项 - **`const` vs `constexpr`**: - `const`只保证运行时不修改,但不一定是编译期常量(如`const int x = get_value();`)。 - `constexpr`强制编译期求值,是更严格的常量。 - **C++标准演进**: - C++11:引入`constexpr`,函数限制严格(单条`return`)。 - C++14:放宽`constexpr`函数限制,允许多条语句、局部变量、循环等。 - C++17:引入`if constexpr`。 ### 示例代码 ```cpp #include <iostream> // C++14起允许循环和局部变量 constexpr int sum_to_n(int n) { int sum = 0; for (int i = 1; i <= n; ++i) { sum += i; } return sum; } int main() { constexpr int n = 10; constexpr int total = sum_to_n(n); // 编译时计算 std::cout << "Sum of 1 to " << n << " is " << total << std::endl; // C++17的if constexpr if constexpr (total > 50) { std::cout << "Large sum\n"; } else { std::cout << "Small sum\n"; } return 0; } ``` ### 判断常量表达式的方法 1. **使用`constexpr`声明**:编译器会在编译时检查是否满足常量表达式要求。 2. **静态断言(static_assert)**: ```cpp static_assert(sum_to_n(10) == 55, "Compile-time check"); ``` 如果`sum_to_n(10)`不是常量表达式或结果错误,编译失败。 > **要点总结**:常量表达式通过编译期计算提升性能,关键工具包括`constexpr`变量/函数和`if constexpr`(C++17)。其核心价值在于将计算从运行时转移到编译时[^1][^2][^5]。 §§相关问题§§ 1. `constexpr`函数在C++11和C++14标准中有何主要区别? 2. 如何在编译时检测一个表达式是否为常量表达式? 3. `if constexpr`与普通`if`语句在性能上有何差异? 4. 常量表达式可以用于哪些标准库容器或算法中? </think> ### C++ 常量表达式详解 #### 1. **定义与本质** 常量表达式(constant expression)指**在编译期间就能计算出结果的表达式**,其值在程序运行前已确定且不可更改。核心特征: - 值必须是编译期可知的常量 - 可参与编译期计算和优化 - 类型必须是字面类型(literal type) ```cpp constexpr int size = 10; // √ 整数字面量 constexpr double pi = 3.14159; // √ 浮点字面量 constexpr char ch = 'A'; // √ 字符字面量 int x = 5; constexpr int invalid = x; // × 非常量初始化 ``` #### 2. **关键特性** | 特性 | 说明 | 示例 | |------|------|------| | **编译期计算** | 值在编译阶段确定 | `constexpr int area = 20*4+8;` | | **强约束性** | 严格限制表达式组成 | 只能包含字面量、常量、其他常量表达式 | | **类型限制** | 仅限字面类型 | 算术类型、引用、指针、特定类类型等 | | **函数要求** | `constexpr`函数需满足特定条件 | 详见表3 | **表:`constexpr`函数要求(C++11 vs C++14)** | 要求 | C++11标准 | C++14放宽 | |------|-----------|-----------| | 函数体 | 只能包含单条`return` | 允许多条语句 | | 局部变量 | 禁止 | 允许(但需常量初始化) | | 控制流 | 禁止循环/条件 | 允许`for`/`if` | | 返回类型 | 必须返回字面类型 | 同左 | | 前置要求 | 使用前必须定义 | 同左 | #### 3. **核心用途** 1. **数组维度定义** ```cpp constexpr int N = 100; int arr[N]; // 合法:编译期确定数组大小 ``` 2. **模板非类型参数** ```cpp template<int Size> struct Buffer { /*...*/ }; Buffer<sizeof(int)*8> buf; // 使用常量表达式实例化 ``` 3. **编译时计算优化** ```cpp constexpr int factorial(int n) { return (n <= 1) ? 1 : n * factorial(n-1); } int arr[factorial(5)]; // 120元素数组,编译期计算 ``` 4. **条件编译(C++17)** ```cpp if constexpr (sizeof(void*) == 8) { // 64位平台专用代码 } else { // 32位平台代码 } ``` #### 4. **判断常量表达式的方法** 1. **使用`constexpr`声明** ```cpp constexpr auto val = expression; // 编译失败则非常量 ``` 2. **静态断言检测** ```cpp static_assert(expression, "Error"); // 编译期检查 ``` 3. **模板参数验证** ```cpp template<int V> struct Test {}; Test<expression> t; // 只接受常量表达式 ``` #### 5. **典型错误示例** ```cpp constexpr int f() { int x = 1; // √ C++14允许局部变量 // return rand(); // × 禁止调用非constexpr函数 return x + 5; } void test() { int d = 10; // constexpr int e = d; // × d不是常量 constexpr int e = f(); // √ } ``` #### 6. **最佳实践建议** 1. 优先用`constexpr`替代`const`声明编译期常量 2. 对数学计算、查找表等使用`constexpr`函数 3. 在模板元编程中充分利用编译期计算 4. C++17+项目使用`if constexpr`简化条件编译 > **核心价值**:常量表达式将计算从运行时转移到编译时,提升性能并增强类型安全。尤其在资源受限系统和模板元编程中发挥关键作用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值