C++常量

C++的常量.

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

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

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

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数: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 . . . 一个或多个数字的十六进制数

字符串常量

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

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

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

1
2
3
4
5
6
7
"hello, dear"

"hello,

dear"

"hello, " "d" "ear"

定义常量

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

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

#define 预处理器

下面是使用 #define 预处理器定义常量的形式:

1

具体请看下面的实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;

#define LENGTH 10
#define WIDTH 5
#define NEWLINE 'n'

int ()
{

int area;

area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}

宏定义是可以取消的

1
2
定义: #define    N    21
取消: #undef N 12

define定义表达式时要注意“边缘效应”,例如如下定义:

#define N 2+3 //我们预想的N值是5,我们这样使用N,int a = N/2; //我们预想的a的值是2,可实际上a的值是3。原因在于在预处理阶段,编译器将 a = N/2处理成了 a = 2+3/2;这就是宏定义的字符串替换的“边缘效应”因此要如下定义:#define N (2+3)。const定义的表达式则没有上述问题。const定义的常量叫做常变量原因有二:const定义常量像变量一样检查类型;const可以在任何地方定义常量,编译器对它的处理过程与变量相似,只是分配内存的地方不同.

const 关键字

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

1
const type variable = value;

具体请看下面的实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#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;
}

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

1
2
3
const int A=10;       
const int A;
extern const int A; //正确,使用extern的外部变量。

const关键字作用

  • 为给读你代码的人传达非常有用的信息,声明一个参数为常量是为了告诉用户这个参数的应用目的;
  • 通过给优化器一些附加信息,使关键字const也许能产生更紧凑的代码;
  • 合理使用关键字const可以使编译器很自然的保护那些不希望被修改的参数,防止无意的代码修改,可以减少bug的出现;

const关键字应用

  • 欲阻止一个变量被改变,可使用const,在定义该const变量时,需先初始化,以后就没有机会改变他了;
  • 对指针而言,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const;
  • 在一个函数声明中,const可以修饰形参表明他是一个输入参数,在函数内部不可以改变其值;
  • 对于类的成员函数,有时候必须指定其为const类型,表明其是一个常函数,不能修改类的成员变量;
  • 对于类的成员函数,有时候必须指定其返回值为const类型,以使得其返回值不为“左值”。

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

类型和安全检查不同

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

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

编译器处理不同

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

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

存储方式不同

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

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

定义域不同

#define:

不管是在某个函数内,还是在所有函数之外,作用域都是从定义开始直到整个文档结尾。

1
2
3
4
5
6
7
8
9
10
void f1 ()
{
#define N 12
const int n 12;
}
void f2 ()
{
cout<<N <<endl; //正确,N已经定义过,不受定义域限制
cout<<n <<endl; //错误,n定义域只在f1函数中
}

定义后能否取消

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

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

1
2
3
4
5
6
7
8
void f1()
{
#define N 12
const int n = 12;

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

是否可以做函数参数

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

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