整数常量

可以是十进制、八进制、十六进制的整数常量（注意并没有二进制）。

八进制：前缀0

十六进制：前缀0x（x大小写均可以）

十进制：无前缀默认为十进制

整数常量也可以带后缀，U和L（大小写均可以，但是推荐使用大写形式，因为小写 l 容易极容易看错）。
浮点数常量

可以使用小数形式或指数形式来表示浮点数。

4.44444	//合法
44e4	//合法
44.e4	//合法
4.e-5L	//合法
4e		//不合法，指数部分不完整
.e4		//不合法，缺少数部分


布尔常量

true：真

false：假

true和false都是C++的关键字
字符常量

从形式上来看，字符常量是在单引号中。

如果字符以L（大写）开头，表示该字符为一个宽字符常量（如：L’x’），此时必须存储在wchar_t类型变量中，否则将会为一个窄字符常量（如：‘x’），窄字符常量可以存储在char类型的变量中。

包括：

普通字符（‘x’）；

转义字符（’\t’）；

通用的字符（’\u02C0’）；





转义字符
含义




\\
\字符


\’
'字符


\"
”字符


\?
?字符


\a
警报铃声


\b
退格键


\f
换页符


\n
换行符


\r
回车


\t
水平制表符


\v
垂直制表符


\ooo
一到三位的八进制数（只有\后3位属于该8进制数）


\xhh
一个或多个数字的十六进制数



字符串常量
定义常量

#define预处理（define只是机械的代换在使用的时候推荐加上括号，不然很容易出错）；

const关键字

	#define sum(a,b) a*b
	int a=0;
	a=sum(3+4,1+2);
	printf("%d",a);
	//可能会有人认为是21，其实输出的9
	#define sum(a,b) (a)*(b)
	int a=0;
	a=sum(3+4,1+2);
	printf("%d",a);
	//这时候输出的就是21，而非9

一， 合法标识符

用户定义的合法标识符需满足以下两个要求：

标识符只能由字母，数字和下划线组成。
标识符不能以数字开头。

二， 合法常量


整型常量：

十进制 ：10

八进制 ：017（以0开头，不能出现8，9）

十六进制：0xA1（以0x开头）


实型常量：（强调E）

E的前面必须有数字，E的后面必须是整数


字符型： 'n' ,'N' ,'\n'


字符串型："abc","123",""


三，合法转义字符

一般转义字符

\a           响铃

\b          退格

\f           换页

\n          换行

\r           回车

\t           水平制表

\v          垂直制表

\          代表一个反斜线字符

\ ’          代表一个单引号字符

"         代表一个双引号字符

\0        空字符
八进制转义字符

它是由反斜杠\和随后的1～3个八进制数字构成的字符序列
十六进制转义字符

它是由反斜杠\和字母x(或X)及随后的1～2个十六进制数字构成的字符序列

（八进制转义字符和十六进制转义字符，不在前面加0！）

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 值代表假。
字符常量
字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L'x'），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 'x'），此时它可以存储在 char 类型的简单变量中。
字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 't'），或一个通用的字符（例如 'u02C0'）。
在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（n）或制表符（t）等。下表列出了一些这样的转义序列码：
字符串常量
字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。
您可以使用空格做分隔符，把一个很长的字符串常量进行分行。
下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。
"hello, dear"
"hello, 
dear"
"hello, " "d" "ear"
定义常量
在 C++ 中，有两种简单的定义常量的方式：
使用 #define 预处理器。
使用 const 关键字。
#define 预处理器
下面是使用 #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 前缀声明指定类型的常量，如下所示：
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
请注意，把常量定义为大写字母形式，是一个很好的编程实践。

心得：
这两种方式在语法上都是合法的，但是第二种方式要比第一种方式好，因为如果使用#define定义宏，PI会在代码的预编译阶段被预编译处理器替换成3.14159，宏的名称不会出现在符号表中，这样会给代码后期的调试带来麻烦，可能会遇到一个数字，却不知道它从何而来，这就是我们常说的Magic
 Number（像拥有魔力一样不知从何而来的数）。使用const定义，既可以保证PI值的唯一性，又便于调试，同时还可以对数据类型进行检查，借助编译器来减少错误的发生。所以，我们总是优先使用const关键字来定义常量。





用宏表示常数

假如我们要写一个有关圆的种种计算的程序，那么∏(3.14159)值会被濒繁用到。我们显然没有理由去改∏的值，所以应该将它当成一个常量对待，那么，我们是否就不得不一遍一遍地写3.14159这一长串的数呢？

必须有个偷懒的方法，并且要提倡这个偷懒，因为多次写3.14159，难免哪次就写错了。

这就用到了宏。宏不仅可以用来代替常数值，还可以用来代替表达式，甚至是代码段。（宏的功能很强大，但也容易出错，所以其利弊大小颇有争议。）今天我们只谈其中代替常数值的功能。

宏的语法为：

　

#define 宏名称 宏值

　

比如要代替前面说到的∏值，应为：

　

#define PAI 3.14159

　

注意，宏定义不是C或C++严格意义上的语句，所以其行末不用加分号结束。

　

宏名称的取名规则和变量名一样，所以我们这里用PAI来表示∏，因为C、C++不能直接使用∏字符。有了上面的语句，我们在程序中凡是要用到3.14159的地方都可以使用PAI这个宏来取代。

作为一种建议和一种广大程序员共同的习惯，宏名称经常使用全部大写的字母。

　

假设原来有一段代码：

　

double zc = 2 * 3.14159 * R; //求圆周长，其中R是代表半径的变量

double mj = 3.14159 * R * R; //求圆面积

　

在定义了宏PAI以后，我们就可以这样使用：

#define PAI 3.14159

　

double = 2 * PAI * R; //求圆周长，其中R是代表半径的变量

double = PAI * R * R; //求圆面积

　

用宏来取代常数，好处是：

　

1)让代码更简洁明了

当然，这有赖于你为宏取一个适当的名字。一般来说，宏的名字更要注重有明确直观的意义，有时宁可让它长点。

2)方便代码维护

就如前面说的3.14159。哪天你发现这个∏值精度不够，想改为3.1415926，那么你只修改一处宏，而不是修改代码中的所有宏。

原来的宏：

#define PAI 3.14159

修改后的宏：

#define PAI 3.1415926

　

对宏的处理，在编译过程中称为“预处理”。也就是说在正式编译前，编译器必须先将代码出现的宏，用其相应的宏值替换，这个过程有点你我在文字处理软件中的查找替换。完成预处理后，所有原来的“PAI”都成了立即数3.1415926。所以在代码中使用宏表达常数，归根结底还是使用了立即数，并没有明确指定这个量的类型。这容易带来一些问题，所以C++使用另一更稳妥的方法来代替宏的这一功能。

常量定义

常量定义的格式为：

　

const 数据类型 常量名 = 常量值;

　

相比变量定义的格式，常量定义必须以 const 开始，另外，常量必须在定义的同时，完成赋值。

　

const float PAI = 3.1415926;

　

const 的作用就是指明这个量（PAI)是常量，而非变量。

常量必须一开始就指定一个值，然后，在以后的代码中，我们不允许改变PAI的值，比如：

　

const float PAI = 3.14159;

double zc = 2 * PAI * R;

PAI = 3.1415926;        //错误！，PAI不能再修改。

double mj = PAI * R * R; 

　

如果一个常量是整型，可以省略指出数据类型，如：

const k = 100;

相当于

const int k = 100;

　

反过来说，如果不指定数据类型，则编译器将它当成整型。比如：

const k = 1.234;

虽然你想让k等于一个实型数，然而，最终k的值其实是1。因为编译器把它当成整型常量。

我们建议在定义变量时，明确指出类型，不管它是整型或其它类型。

　

const int i = 100;

const double di = 100.0;

ref1:http://www.howzhi.com/course/3687/lesson/43502

ref2:http://www.cnblogs.com/particle/archive/2012/09/01/2667042.html

ref3:http://learn.akae.cn/media/ch21s02.html(宏定义的使用)