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;
}
 

运行结果如下：