C++的数据类型
C++中的数据类型
C++中的数据类型分为两大类：基本数据类型和非基本数据类型，如下图所示：
本文重点介绍C++中各种基本数据类型及相关知识。
C++中各种基本数据类型的详细说明如下表所示：
| 类 型 |
名 称 |
占用字节数 |
取 值 范 围 |
| Bool |
布尔型 |
1 |
true,false |
| [signed] char |
有符号字符型 |
1 |
-128～127 |
| unsiged char |
无符号字符型 |
1 |
0～255 |
| [signed] short [int] |
有符号短整型 |
2 |
-32768～32767 |
| unsigned short [int] |
无符号短整型 |
2 |
0～65535 |
| [signed] int |
有符号整型 |
4 |
-(2的31次方)～(2的31次方-1) |
| unsigned [int] |
无符号整型 |
4 |
0～(2的32次方-1) |
| [signed] long [int] |
有符号长整型 |
4 |
-(2的31次方)～(2的31次方-1) |
| unsigned long [int] |
无符号长整型 |
4 |
0～(2的32次方-1) |
| float |
实型（浮点型） |
4 |
|
| double |
双精度型 |
8 |
|
| long double |
长双精度型 |
16 |
|
| void |
无值型 |
0 |
无值 |
表中用[ ]括起来的部分在书写时可以省略。大小会根据编译器和所使用的电脑而有所不同。
c++中bool类型
用true和false来表示真或者假，也可以用非0值来表示true，用0来表示false。
下面实例会输出您电脑上各种数据类型的大小：
#include
#include
using namespace std;
int main()
{
cout << "type: \t\t" << "************size**************"<< endl;
cout << "bool: \t\t" << "所占字节数：" << sizeof(bool);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t\t最小值：" << (numeric_limits::min)() << endl;
cout << "char: \t\t" << "所占字节数：" << sizeof(char);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t\t最小值：" << (numeric_limits::min)() << endl;
cout << "signed char: \t" << "所占字节数：" << sizeof(signed char);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t\t最小值：" << (numeric_limits::min)() << endl;
cout << "unsigned char: \t" << "所占字节数：" << sizeof(unsigned char);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t\t最小值：" << (numeric_limits::min)() << endl;
cout << "wchar_t: \t" << "所占字节数：" << sizeof(wchar_t);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t\t最小值：" << (numeric_limits::min)() << endl;
cout << "short: \t\t" << "所占字节数：" << sizeof(short);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t\t最小值：" << (numeric_limits::min)() << endl;
cout << "int: \t\t" << "所占字节数：" << sizeof(int);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "unsigned: \t" << "所占字节数：" << sizeof(unsigned);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "long: \t\t" << "所占字节数：" << sizeof(long);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "unsigned long: \t" << "所占字节数：" << sizeof(unsigned long);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "double: \t" << "所占字节数：" << sizeof(double);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "long double: \t" << "所占字节数：" << sizeof(long double);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "float: \t\t" << "所占字节数：" << sizeof(float);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "size_t: \t" << "所占字节数：" << sizeof(size_t);
cout << "\t最大值：" << (numeric_limits::max)();
cout << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "string: \t" << "所占字节数：" << sizeof(string) << endl;
// << "\t最大值：" << (numeric_limits::max)() << "\t最小值：" << (numeric_limits::min)() << endl;
cout << "type: \t\t" << "************size**************"<< endl;
return 0;
}
此例使用了 endl，这将在每一行后插入一个换行符，<< 运算符用于向屏幕传多个值。我们也使用 sizeof() 函数来获取各种数据类型的大小。
当上面的代码被编译和执行时，它会产生以下的结果，结果会根据所使用的计算机而有所不同：
C++变量
变量：在程序中是指可以改变值的量。每个变量具有 变量名，用于标识变量的标识符，其实质是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型。
变量的说明：任何变量都必须先说明后使用。
目的：一是便于编译程序为变量分配空间，二是便于编译时进行语法检查。
格式：在C++中，变量说明的一般格式为：
[存储类型]<数据类型> <变量名1>[,<变量名2>,…,<变量名n>]；
例，下面是变量说明的几个例子：
int i, j; //说明2个整型变量i,j
float x,y,z; //说明3个实型变量x,y,z
char c1, c2; //说明2个字符型变量c1,c2
变量的使用：变量使用的第一步，是给变量赋初始值，称为“初始化”。有两种方法：
变量说明时直接赋初值：
int a=3, b=4;
float x=3.0；
用赋值语句赋初值：
float x, e;
x=3.5;
e=2.71828;
C++ 变量作用域
所谓作用域（Scope），就是变量的有效范围，就是变量可以在哪个范围以内使用。有些变量可以在所有代码文件中使用，有些变量只能在当前的文件中使用，有些变量只能在函数内部使用，有些变量只能在 for 循环内部使用。
函数（包括main函数）的形参和在该函数里定 义的变量都被称为该函数的局部变量**（local variable）。不同函数的局部变量相互独 立，即 无法访问其他函数的局部变量。需要注意的是，局部变量的存储空间是临时分配的，函数执 行完毕时，局部变量的空间将被释放，其中的值无法保留到下次使用。与此对应的是全局变 量（global variable）：此变量在函数外声明，可以在任何时候，由任何函数访问。需要注意 的是，应该谨慎使用全局变量。
介绍函数时还将介绍。
C++常量
常量是指取值在程序的执行过程中始终保持不变的量，又分为文字常量（Literal constant）和常变量（也称“符号常量”）。
文字常量指程序中直接给出的量。文字常量存储在程序区，而不是数据区；对它的访问不是通过数据地址进行的。
根据取值和表示方法的不同，可分为整型常量、实型常量、字符型常量和字符串常量。
整数常量
整数常量可以是十进制、八进制或十六进制的常量。不带前缀则默认表示十进制，前缀0x 或 0X 表示十六进制，前缀0 表示八进制。
整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
例：
85 // 十进制
0213 // 八进制
0x4b // 十六进制
30 // 整数
30u // 无符号整数
30l // 长整数
30ul // 无符号长整数
浮点常量
浮点常量由整数部分、小数点、小数部分和指数部分组成。
一般形式：与平时书写形式相同，由数字0 ～9和小数点组成。如：
0.23、 -125.76、 0.0、 .46、 -35.
指数形式：即科学表示法，表示为尾数乘以10的次方形式，由尾数、E或e和阶数组成。要求在E或e前面的尾数部分必须有数字，后面的指数部分必须为整数。如：
123E12、 -.34e-2、314159E-5L
布尔常量
布尔常量共有两个，它们都是标准的 C++ 关键字：
true 值代表真。
false 值代表假。
字符型常量
字符型常量：用单引号引起来的单个字符。
保存形式：在内存中保存的是字符的ASCII码值。
直接表示形式：对于可显示字符，通常用单引号直接引起来表示。例如：
'a' //字符a
'4' //字符4
'@' //字符@
' ' //空格字符
转义序列表示法：对于不可显示的或无法从键盘输入的字符，如回车符、换行符、制表符、响铃、退格等；另外，还有几个具有特殊含义的字符，如反斜杠、单引号和双引号等，C++提供了一种称为“转义序列”的表示方法。例如：
'\a' //响铃
'\n' //换行符
'\\' //字符\
字符串常量
字符串常量：由一对双引号″″引起来的若干个字符组成。例如：″I am a Chinese.″、 ″123″、 ″a″、 ″ ″
字符串常量与字符型常量的区别如下：
字符串常量″a″占两个字节，存放'a'和'\0'，如图左半部分，值为0x6100；
字符型常量'a' 占一个字节，存放'a'，如图右半部分，值为0x61。
常变量
用常量说明符const给文字常量命名所得的标识符就称为“标识符常量”。因为标识符常量的说明和引用形式很像变量，所以也称“常变量”。如：
const float PI=3.14159; //定义了常变量PI
常变量(constant variable)又称为只读变量(read-only-variable)。在使用常变量时应注意以下几点：
常变量必须也只能在说明时进行初始化。
常变量初始化之后，不允许再被赋值。
常变量必须先说明后使用。
还可以使用 #define命令定义的符号常量。如：
#define WIDTH 5
#define NEWLINE '\n'
请区别用#define命令定义的符号常量和用const定义的常变量。符号常量只是用一个符号代替一个字符串，在预编译时把所有符号常量替换为所指定的字符串，它没有类型，在内存中并不存在以符号常量命名的存储单元。而常变量具有变量的特征，它具有类型，在内存中存在着以它命名的存储单元，可以用sizeof运算符测出其长度。与一般变量惟一的不同是指定变量的值不能改变。用#define命令定义符号常量是C语言所采用的方法，C++把它保留下来是为了和C兼容。C++的程序员一般喜欢用const定义常变量。虽然二者实现的方法不同，但从使用的角度看，都可以认为用了一个标识符代表了一个常量。
C++的表达式、运算符、优先级和结合性
表达式是指由运算符、操作数及标点符号组成的式子。
运算符指对常量或变量进行运算或处理的符号。参与运算的数值或变量称为“操作数”。
运算符的“优先级”指不同运算符在运算中的优先关系。
运算符的“结合性”决定同优先级的运算符对操作数的运算次序。从左到右运算称为“右结合”，从右到左称为“左结合”。如，+、-的结合性是从左到右（右结合），则a+b+c-d的运算次序为：((a+b)+c)-d //先算a+b，再加c，最后减d
同一优先级的运算符有相同的结合性。
按照要求的操作数个数，运算符分为单目（一元）运算符、双目（二元）运算符和三目（三元）运算符：
单目运算符只对一个操作数运算，如负号运算符“-”等。
双目运算符要求有两个操作数，如乘号运算符“*”等。
三目运算符要求有三个操作数，三目运算符只有一个“?:”。
算术运算符
下表显示了 C++ 支持的算术运算符：
其中两个变量A = 10，B = 20
| 运算符 |
描述 |
实例 |
| + |
把两个操作数相加 |
A + B 将得到 30 |
| - |
从第一个操作数中减去第二个操作数 |
A - B 将得到 -10 |
| * |
把两个操作数相乘 |
A * B 将得到 200 |
| / |
分子除以分母 |
B / A 将得到 2 |
| % |
取模运算符，整除后的余数 |
B % A 将得到 0 |
| ++ |
自增运算符，整数值增加 1 |
A++ 将得到 11 |
| -- |
自减运算符，整数值减少 1 |
A-- 将得到 9 |
整数运算遵循四则运算规则，可以使用任意嵌套的小括号。四则运算规则和初等数学一致。
注意，整数除法就是整数结果，如果有浮点数才会出现浮点结果。例如
#include
using namespace std;
int main()
{
int b = 101;
double p;
p = b/2;
cout << p<< endl;
return 0;
}
运行测试结果如下：
将其中一个数改成浮点型，将p = b/2; 改为： p = b/2.0; 或 p =b/(double)2; 得到准确结果。
自增、自减运算符的说明
操作数只能是变量，不能是常量或表达式
分前置和后置两种运算:，例如：
int i=5, j=5, m, n;
m=i++; //后置++；相当于m=i; i=i+1; 结果：i的值为6，m的值为5;
n=++j; //前置++；相当于j=j+1;n=j; 结果：j的值为6，n的值为6;
赋值运算符
下表列出了 C++ 支持的赋值运算符：
| 运算符 |
描述 |
实例 |
| = |
简单的赋值运算符，把右边操作数的值赋给左边操作数 |
C = A + B 将把 A + B 的值赋给 C |
| += |
加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 |
C += A 相当于 C = C + A |
| -= |
减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 |
C -= A 相当于 C = C - A |
| *= |
乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 |
C *= A 相当于 C = C * A |
| /= |
除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 |
C /= A 相当于 C = C / A |
| %= |
求模且赋值运算符，求两个操作数的模赋值给左边操作数 |
C %= A 相当于 C = C % A |
| <<= |
左移且赋值运算符 |
C <<= 2 等同于 C = C << 2 |
| >>= |
右移且赋值运算符 |
C >>= 2 等同于 C = C >> 2 |
| &= |
按位与且赋值运算符 |
C &= 2 等同于 C = C & 2 |
| ^= |
按位异或且赋值运算符 |
C ^= 2 等同于 C = C ^ 2 |
| |= |
按位或且赋值运算符 |
C |= 2 等同于 C = C | 2 |
赋值运算符：“＝”，其意义是将赋值号右边的值送到左边变量所标识的单元中。左操作数称为“左值”，而右操作数称为“右值”。“左值”必须放在内存中可以访问且可以合法修改值的存储单元，通常只能是变量名；“右值”则可以是常量，也可以是变量或表达式，但一定能取得确定的值。赋值指将数据存放在相应存储单元中，如果该单元中已有值，将用新值取代旧值。
赋值表达式：由运算符连接的表达式称为格式为：<变量> = <表达式>;
例如：x=x+6;
复合赋值运算：复合赋值运算符的要求与格式和赋值运算符完全相同，表示为：
<变量> <复合赋值运算符> <表达式>;
它等同于：<变量> = <变量> <运算符> （<表达式>）;
例：x+=5; 等同与 x=x+5;
关系运算符
下表显示了 C++ 支持的关系运算符：
其中两个变量A = 10，B = 20
| 运算符 |
描述 |
实例 |
| == |
检查两个操作数的值是否相等，如果相等则条件为真。 |
(A == B) 不为真。 |
| != |
检查两个操作数的值是否相等，如果不相等则条件为真。 |
(A != B) 为真。 |
| > |
检查左操作数的值是否大于右操作数的值，如果是则条件为真。 |
(A > B) 不为真。 |
| < |
检查左操作数的值是否小于右操作数的值，如果是则条件为真。 |
(A < B) 为真。 |
| >= |
检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 |
(A >= B) 不为真。 |
| <= |
检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 |
(A <= B) 为真。 |
关系表达式：由关系运算符连接而成的表达式，结果为逻辑值。
逻辑运算符
逻辑值：在c++中，逻辑值与整数有一个对应关系：true对应1，false对应0。反过来，0对应false，非0整数对应true。所以，逻辑运算的结果可作为整数参与其他运算；整型数也可参与逻辑运算。
下表显示了 C++ 支持的关系逻辑运算符：
其中两个变量A = 1，B = 0
| 运算符 |
描述 |
实例 |
| && |
称为逻辑与运算符。如果两个操作数都 true，则条件为 true。 |
(A && B) 为 false。 |
| || |
称为逻辑或运算符。如果两个操作数中有任意一个 true，则条件为 true。 |
(A || B) 为 true。 |
| ! |
称为逻辑非运算符。用来逆转操作数的逻辑状态，如果条件为 true 则逻辑非运算符将使其为 false。 |
!(A && B) 为 true。 |
☆逻辑表达式：由逻辑运算符连接的表达式，结果为逻辑值。关系表达式是一种最简单的逻辑表达式。计算时，逻辑非优先级最高，关系运算其次，逻辑与和逻辑或最低。
例：假定a=3, b=0,c=5,d=2,x=6,y=2; 试分析下面的关系表达式：:
a>b>c //先求a>b，结果为true，即1，再将结果1与c比较，结果为假
a+b>c+d //等同于(a+b)>(c+d)，结果为假
a>b&&ay)-!a
//相当于((a>b)&&(ay)-(!a))，结果为true
☆逻辑表达式的求值优化：在逻辑表达式的求值过程中，并非先将所有逻辑运算都做完再得结果，而是一旦表达式的值能够确定，就不再进行后面的运算。
例：假定a=2, b=0, c=3; 则逻辑表达式 a||b++||c-- 产生的结果是：
【解析】：a=2，第一个操作数为1；1与任何值相或的结果总是1（true）；所以不用再计算b++和c--，则此b的值仍为0，c的值仍为3；整个表达式的值为1。
位运算符
位运算：c++语言提供字位运算，直接对操作数的二进制位进行操作。位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
| p |
q |
p & q |
p | q |
p ^ q |
| 0 |
0 |
0 |
0 |
0 |
| 0 |
1 |
0 |
1 |
1 |
| 1 |
1 |
1 |
1 |
0 |
| 1 |
0 |
0 |
1 |
1 |
假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表显示了 C++ 支持的位运算符。其中两个变量，A = 60，B = 13，则：
| 运算符 |
描述 |
实例 |
| & |
如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 |
(A & B) 将得到 12，即为 0000 1100 |
| | |
如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 |
(A | B) 将得到 61，即为 0011 1101 |
| ^ |
如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 |
(A ^ B) 将得到 49，即为 0011 0001 |
| ~ |
二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。 |
(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。 |
| << |
二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 |
A << 2 将得到 240，即为 1111 0000 |
| >> |
二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 |
A >> 2 将得到 15，即为 0000 1111 |
其它运算符
下表列出了 C++ 支持的其他一些重要的运算符：
| 运算符 |
描述 |
| sizeof |
sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。 |
| Condition ? X : Y |
条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。 |
| , |
逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。 |
| .（点）和 ->（箭头） |
成员运算符用于引用类、结构和共用体的成员。 |
| Cast |
强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。 |
| & |
指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。 |
| * |
指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。 |
☆sizeof( )运算符
sizeof运算符：用于计算存储一种数据类型或一个变量所需的字节数。一般格式为：
sizeof (<数据类型>) 或 sizeof(<变量名>)
几点说明：
数据类型可以是标准数据类型，也可以是用户自定义类型。
变量必须是已定义的变量。
括号可以省略，运算符与操作数之间用空格间隔。
sizeof()应用举例：
sizeof(int); //值为4
sizeof(float); //值为4
设：double x;
则：sizeof(x); //值为8
☆逗号运算符：C++中，逗号既是分隔符，又是运算符，且优先级最低。
逗号表达式：用逗号连接起来的表达式，其一般格式为：
<表达式1>，<表达式2>，…，<表达式n>
运算规则是：从左到右依次求出各表达式的值，并将最后一个表达式的值当做整个逗号表达式的值。
例：若a=1，b=2，c=3; 以下逗号表达式的结果是：
c=b=(a=3，4*3) //结果为：a=3，b=12，c=12，表达式的值为12
c=b=a=3，4*3 //结果为：a=3，b=3，c=3，表达式的值为12
c=(b=a=3，4*3) //结果为：a=3，b=3，c=12，表达式的值为12
C++ 中的运算符优先级
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
下表将按运算符优先级从高到低列出各个运算符,表中靠前的优先级高于后面的。在表达式中，较高优先级的运算符会优先被计算。
| 类别 |
运算符 |
结合性 |
| 后缀 |
() [] -> . ++ - - |
从左到右 |
| 一元 |
+ - ! ~ ++ - - (type)* & sizeof |
从右到左 |
| 乘除 |
* / % |
从左到右 |
| 加减 |
+ - |
从左到右 |
| 移位 |
<< >> |
从左到右 |
| 关系 |
< <= > >= |
从左到右 |
| 相等 |
== != |
从左到右 |
| 位与 AND |
& |
从左到右 |
| 位异或 XOR |
^ |
从左到右 |
| 位或 OR |
| |
从左到右 |
| 逻辑与 AND |
&& |
从左到右 |
| 逻辑或 OR |
|| |
从左到右 |
| 条件 |
?: |
从右到左 |
| 赋值 |
= += -= *= /= %=>>= <<= &= ^= |= |
从右到左 |
| 逗号 |
, |
从左到右 |
例、
int x=10;
x += 5 == 4; // x=10
【分析】x += 5 == 4和 x +=(5 == 4)等价<先判断 5 == 4是否成立，此时不成立，返回false，即返回0；然后再计算x+=0，所以最终结果为10。
建议在编码的时，尽量不要让人产生歧义的代码。
数据类型的转换
☆自动转换/隐式转换
不同类型的数据进行运算，需先转换成同一类型；
转换按数据长度增加的方向进行，以保证精度不降低；
所有的浮点运算都是以双精度进行的；
char 型和 short 型参与运算时，必须先转换成 int 型；
赋值号两边的数据类型不同时，右边的类型将转换为左边的。
char → short → int → long → unsigned long → double ← float
转换规则
浮点型转整型：直接丢掉小数部分；
字符型转整型：取字符的 ASCII 码；
整型转字符型：取 ASCII 码对应的字符。
例、数据类型的隐式转换
#include
using namespace std;
int main()
{
int k=2;
cout << "k=" << k << endl;
double x=3.2, y;
y=k+x;
cout << "y=" << y << endl;
int i;
char a;
i=3.6;
cout << "i=" << i << endl;
i=-3.6;
cout << "i=" << i << endl;
i='m';
cout << "i=" << i << endl;
a=90;
cout << "a=" << a << endl;
return 0;
}
运行结果如下：
☆强制转换/显式转换
类型说明符(表达式) // C++ 风格
(类型说明符)表达式 // C 风格
将表达式的值转换成指定的数据类型。
注：类型转换不会改变变量的数据类型！
例、数据类型的显式转换
例、数据类型的显式转换
#include
using namespace std;
int main()
{
int a=2, b=5;
double x, y, z1, z2;
x=b/a;
cout << "x=" << x << endl;
y=double(b)/a;
cout << "y=" << y << endl;
z1=double(b/a);
z2=double(b)/double(a);
cout << "b/a=" << b/a << endl;
cout << "z1=" << z1 << endl;
cout << "z2=" << z2 << endl;
return 0;
}
运行结果如下：
