C++的数据类型

心已赠人 2022-12-11 07:54 103阅读 0赞

### **C++的数据类型** ###

C++中的数据类型

C++中的数据类型分为两大类：基本数据类型和非基本数据类型，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70][]

本文重点介绍C++中各种基本数据类型及相关知识。

C++中各种基本数据类型的详细说明如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#cccccc;"> 类 型 </td> 
 <td style="border-color:#cccccc;"> 名 称 </td> 
 <td style="border-color:#cccccc;"> 占用字节数 </td> 
 <td style="border-color:#cccccc;"> 取 值 范 围 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> Bool </td> 
 <td> 布尔型 </td> 
 <td> 1 </td> 
 <td> true,false </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> [signed] char </td> 
 <td> 有符号字符型 </td> 
 <td> 1 </td> 
 <td> -128～127 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> unsiged char </td> 
 <td> 无符号字符型 </td> 
 <td> 1 </td> 
 <td> 0～255 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> [signed] short [int] </td> 
 <td> 有符号短整型 </td> 
 <td> 2 </td> 
 <td> -32768～32767 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> unsigned short [int] </td> 
 <td> 无符号短整型 </td> 
 <td> 2 </td> 
 <td> 0～65535 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> [signed] int </td> 
 <td> 有符号整型 </td> 
 <td> 4 </td> 
 <td> -(2的31次方)～(2的31次方-1) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> unsigned [int] </td> 
 <td> 无符号整型 </td> 
 <td> 4 </td> 
 <td> 0～(2的32次方-1) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> [signed] long [int] </td> 
 <td> 有符号长整型 </td> 
 <td> 4 </td> 
 <td> -(2的31次方)～(2的31次方-1) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> unsigned long [int] </td> 
 <td> 无符号长整型 </td> 
 <td> 4 </td> 
 <td> 0～(2的32次方-1) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> float </td> 
 <td> 实型（浮点型） </td> 
 <td> 4 </td> 
 <td> </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> double </td> 
 <td> 双精度型 </td> 
 <td> 8 </td> 
 <td></td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> long double </td> 
 <td> 长双精度型 </td> 
 <td> 16 </td> 
 <td> </td> 
 </tr> 
 <tr> 
 <td style="border-color:#cccccc;"> void </td> 
 <td> 无值型 </td> 
 <td> 0 </td> 
 <td> 无值 </td> 
 </tr> 
 </tbody> 
</table>

表中用\[ \]括起来的部分在书写时可以省略。大小会根据编译器和所使用的电脑而有所不同。

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() 函数来获取各种数据类型的大小。

当上面的代码被编译和执行时，它会产生以下的结果，结果会根据所使用的计算机而有所不同：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1][]

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

<table style="width:424.85pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:57.3pt;"> 运算符 </td> 
 <td style="border-color:#555555;width:176.2pt;"> 描述 </td> 
 <td style="border-color:#555555;width:191.35pt;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> + </td> 
 <td style="width:176.2pt;"> 把两个操作数相加 </td> 
 <td style="width:191.35pt;"> A + B 将得到 30 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> - </td> 
 <td style="width:176.2pt;"> 从第一个操作数中减去第二个操作数 </td> 
 <td style="width:191.35pt;"> A - B 将得到 -10 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> * </td> 
 <td style="width:176.2pt;"> 把两个操作数相乘 </td> 
 <td style="width:191.35pt;"> A * B 将得到 200 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> / </td> 
 <td style="width:176.2pt;"> 分子除以分母 </td> 
 <td style="width:191.35pt;"> B / A 将得到 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> % </td> 
 <td style="width:176.2pt;"> 取模运算符，整除后的余数 </td> 
 <td style="width:191.35pt;"> B % A 将得到 0 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> ++ </td> 
 <td style="width:176.2pt;"> <a href="https://www.runoob.com/cplusplus/cpp-increment-decrement-operators.html" rel="nofollow">自增运算符</a>，整数值增加 1 </td> 
 <td style="width:191.35pt;"> A++ 将得到 11 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> -- </td> 
 <td style="width:176.2pt;"> <a href="https://www.runoob.com/cplusplus/cpp-increment-decrement-operators.html" rel="nofollow">自减运算符</a>，整数值减少 1 </td> 
 <td style="width:191.35pt;"> A-- 将得到 9 </td> 
 </tr> 
 </tbody> 
</table>

整数运算遵循四则运算规则，可以使用任意嵌套的小括号。四则运算规则和初等数学一致。

注意，整数除法就是整数结果，如果有浮点数才会出现浮点结果。例如

\#include  
using namespace std;

int main() 
\{ 
   int b = 101; 
   double p; 
   p =  b/2; 
   cout << p<< endl;

return 0;  
\}

运行测试结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2][]

将其中一个数改成浮点型，将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++ 支持的赋值运算符：

<table style="width:423.9pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:42.15pt;"> 运算符 </td> 
 <td style="border-color:#555555;width:240pt;"> 描述 </td> 
 <td style="border-color:#555555;width:5cm;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> = </td> 
 <td style="width:240pt;"> 简单的赋值运算符，把右边操作数的值赋给左边操作数 </td> 
 <td style="width:5cm;"> C = A + B 将把 A + B 的值赋给 C </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> += </td> 
 <td style="width:240pt;"> 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 </td> 
 <td style="width:5cm;"> C += A 相当于 C = C + A </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> -= </td> 
 <td style="width:240pt;"> 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 </td> 
 <td style="width:5cm;"> C -= A 相当于 C = C - A </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> *= </td> 
 <td style="width:240pt;"> 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 </td> 
 <td style="width:5cm;"> C *= A 相当于 C = C * A </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> /= </td> 
 <td style="width:240pt;"> 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 </td> 
 <td style="width:5cm;"> C /= A 相当于 C = C / A </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> %= </td> 
 <td style="width:240pt;"> 求模且赋值运算符，求两个操作数的模赋值给左边操作数 </td> 
 <td style="width:5cm;"> C %= A 相当于 C = C % A </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> &lt;&lt;= </td> 
 <td style="width:240pt;"> 左移且赋值运算符 </td> 
 <td style="width:5cm;"> C &lt;&lt;= 2 等同于 C = C &lt;&lt; 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> &gt;&gt;= </td> 
 <td style="width:240pt;"> 右移且赋值运算符 </td> 
 <td style="width:5cm;"> C &gt;&gt;= 2 等同于 C = C &gt;&gt; 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> &amp;= </td> 
 <td style="width:240pt;"> 按位与且赋值运算符 </td> 
 <td style="width:5cm;"> C &amp;= 2 等同于 C = C &amp; 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> ^= </td> 
 <td style="width:240pt;"> 按位异或且赋值运算符 </td> 
 <td style="width:5cm;"> C ^= 2 等同于 C = C ^ 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:42.15pt;"> |= </td> 
 <td style="width:240pt;"> 按位或且赋值运算符 </td> 
 <td style="width:5cm;"> C |= 2 等同于 C = C | 2 </td> 
 </tr> 
 </tbody> 
</table>

赋值运算符：“＝”，其意义是将赋值号右边的值送到左边变量所标识的单元中。左操作数称为“左值”，而右操作数称为“右值”。“左值”必须放在内存中可以访问且可以合法修改值的存储单元，通常只能是变量名；“右值”则可以是常量，也可以是变量或表达式，但一定能取得确定的值。赋值指将数据存放在相应存储单元中，如果该单元中已有值，将用新值取代旧值。

赋值表达式：由运算符连接的表达式称为格式为：<变量> = <表达式>;

例如：x=x+6;

复合赋值运算：复合赋值运算符的要求与格式和赋值运算符完全相同，表示为：

<变量> <复合赋值运算符> <表达式>;

它等同于：<变量> = <变量> <运算符> （<表达式>）;

例：x+=5; 等同与 x=x+5;

**关系运算符**

下表显示了 C++ 支持的关系运算符：

其中两个变量A = 10，B = 20

<table style="width:467.4pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:57.3pt;"> 运算符 </td> 
 <td style="border-color:#555555;width:317.95pt;"> 描述 </td> 
 <td style="border-color:#555555;width:92.15pt;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> == </td> 
 <td style="width:317.95pt;"> 检查两个操作数的值是否相等，如果相等则条件为真。 </td> 
 <td style="width:92.15pt;"> (A == B) 不为真。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> != </td> 
 <td style="width:317.95pt;"> 检查两个操作数的值是否相等，如果不相等则条件为真。 </td> 
 <td style="width:92.15pt;"> (A != B) 为真。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &gt; </td> 
 <td style="width:317.95pt;"> 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 </td> 
 <td style="width:92.15pt;"> (A &gt; B) 不为真。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &lt; </td> 
 <td style="width:317.95pt;"> 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 </td> 
 <td style="width:92.15pt;"> (A &lt; B) 为真。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &gt;= </td> 
 <td style="width:317.95pt;"> 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 </td> 
 <td style="width:92.15pt;"> (A &gt;= B) 不为真。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &lt;= </td> 
 <td style="width:317.95pt;"> 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 </td> 
 <td style="width:92.15pt;"> (A &lt;= B) 为真。 </td> 
 </tr> 
 </tbody> 
</table>

关系表达式：由关系运算符连接而成的表达式，结果为逻辑值。

**逻辑运算符**

逻辑值：在c++中，逻辑值与整数有一个对应关系：true对应1，false对应0。反过来，0对应false，非0整数对应true。所以，逻辑运算的结果可作为整数参与其他运算；整型数也可参与逻辑运算。

下表显示了 C++ 支持的关系逻辑运算符：

其中两个变量A = 1，B = 0

<table style="width:460.3pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:57.3pt;"> 运算符 </td> 
 <td style="border-color:#555555;width:296.7pt;"> 描述 </td> 
 <td style="border-color:#555555;width:106.3pt;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &amp;&amp; </td> 
 <td style="width:296.7pt;"> 称为逻辑与运算符。如果两个操作数都 true，则条件为 true。 </td> 
 <td style="width:106.3pt;"> (A &amp;&amp; B) 为 false。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> || </td> 
 <td style="width:296.7pt;"> 称为逻辑或运算符。如果两个操作数中有任意一个 true，则条件为 true。 </td> 
 <td style="width:106.3pt;"> (A || B) 为 true。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> ! </td> 
 <td style="width:296.7pt;"> 称为逻辑非运算符。用来逆转操作数的逻辑状态，如果条件为 true 则逻辑非运算符将使其为 false。 </td> 
 <td style="width:106.3pt;"> !(A &amp;&amp; B) 为 true。 </td> 
 </tr> 
 </tbody> 
</table>

☆逻辑表达式：由逻辑运算符连接的表达式，结果为逻辑值。关系表达式是一种最简单的逻辑表达式。计算时，逻辑非优先级最高，关系运算其次，逻辑与和逻辑或最低。

例：假定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++语言提供字位运算，直接对操作数的二进制位进行操作。位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

假设如果 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，则：

<table style="width:446.65pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:57.3pt;"> 运算符 </td> 
 <td style="border-color:#555555;width:268.35pt;"> 描述 </td> 
 <td style="border-color:#555555;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &amp; </td> 
 <td style="width:268.35pt;"> 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 </td> 
 <td> (A &amp; B) 将得到 12，即为 0000 1100 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> | </td> 
 <td style="width:268.35pt;"> 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 </td> 
 <td> (A | B) 将得到 61，即为 0011 1101 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> ^ </td> 
 <td style="width:268.35pt;"> 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 </td> 
 <td> (A ^ B) 将得到 49，即为 0011 0001 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> ~ </td> 
 <td style="width:268.35pt;"> 二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。 </td> 
 <td> (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &lt;&lt; </td> 
 <td style="width:268.35pt;"> 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 </td> 
 <td> A &lt;&lt; 2 将得到 240，即为 1111 0000 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &gt;&gt; </td> 
 <td style="width:268.35pt;"> 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 </td> 
 <td> A &gt;&gt; 2 将得到 15，即为 0000 1111 </td> 
 </tr> 
 </tbody> 
</table>

**其它运算符**

下表列出了 C++ 支持的其他一些重要的运算符：

<table style="width:453.2pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;"> 运算符 </td> 
 <td style="border-color:#555555;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> sizeof </td> 
 <td> <a href="https://www.runoob.com/cplusplus/cpp-sizeof-operator.html" rel="nofollow">sizeof 运算符</a>返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> Condition ? X : Y </td> 
 <td> <a href="https://www.runoob.com/cplusplus/cpp-conditional-operator.html" rel="nofollow">条件运算符</a>。如果 Condition 为真 ? 则值为 X : 否则值为 Y。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> , </td> 
 <td> <a href="https://www.runoob.com/cplusplus/cpp-comma-operator.html" rel="nofollow">逗号运算符</a>会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> .（点）和 -&gt;（箭头） </td> 
 <td> <a href="https://www.runoob.com/cplusplus/cpp-member-operators.html" rel="nofollow">成员运算符</a>用于引用类、结构和共用体的成员。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> Cast </td> 
 <td> <a href="https://www.runoob.com/cplusplus/cpp-casting-operators.html" rel="nofollow">强制转换运算符</a>把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> &amp; </td> 
 <td> <a href="https://www.runoob.com/cplusplus/cpp-pointer-operators.html" rel="nofollow">指针运算符 &amp;</a>&nbsp;返回变量的地址。例如 &amp;a; 将给出变量的实际地址。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;"> * </td> 
 <td> <a href="https://www.runoob.com/cplusplus/cpp-pointer-operators.html" rel="nofollow">指针运算符 *</a>&nbsp;指向一个变量。例如，*var; 将指向变量 var。 </td> 
 </tr> 
 </tbody> 
</table>

☆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++ 中的运算符优先级**

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

下表将按运算符优先级从高到低列出各个运算符,表中靠前的优先级高于后面的。在表达式中，较高优先级的运算符会优先被计算。

<table style="width:403.1pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:84.65pt;"> 类别&nbsp; </td> 
 <td style="border-color:#555555;width:205.55pt;"> 运算符&nbsp; </td> 
 <td style="border-color:#555555;"> 结合性&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 后缀&nbsp; </td> 
 <td style="width:205.55pt;"> () [] -&gt; . ++ - - &nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 一元&nbsp; </td> 
 <td style="width:205.55pt;"> + - ! ~ ++ - - (type)* &amp; sizeof&nbsp; </td> 
 <td> 从右到左&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 乘除&nbsp; </td> 
 <td style="width:205.55pt;"> * / %&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 加减&nbsp; </td> 
 <td style="width:205.55pt;"> + -&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 移位&nbsp; </td> 
 <td style="width:205.55pt;"> &lt;&lt; &gt;&gt;&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 关系&nbsp; </td> 
 <td style="width:205.55pt;"> &lt; &lt;= &gt; &gt;=&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 相等&nbsp; </td> 
 <td style="width:205.55pt;"> == !=&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 位与 AND&nbsp; </td> 
 <td style="width:205.55pt;"> &amp;&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 位异或 XOR&nbsp; </td> 
 <td style="width:205.55pt;"> ^&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 位或 OR&nbsp; </td> 
 <td style="width:205.55pt;"> |&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 逻辑与 AND&nbsp; </td> 
 <td style="width:205.55pt;"> &amp;&amp;&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 逻辑或 OR&nbsp; </td> 
 <td style="width:205.55pt;"> ||&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 条件&nbsp; </td> 
 <td style="width:205.55pt;"> ?:&nbsp; </td> 
 <td> 从右到左&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 赋值&nbsp; </td> 
 <td style="width:205.55pt;"> = += -= *= /= %=&gt;&gt;= &lt;&lt;= &amp;= ^= |=&nbsp; </td> 
 <td> 从右到左&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:84.65pt;"> 逗号&nbsp; </td> 
 <td style="width:205.55pt;"> ,&nbsp; </td> 
 <td> 从左到右&nbsp; </td> 
 </tr> 
 </tbody> 
</table>

例、

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

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3][]

**☆**强制转换/显式转换  
类型说明符(表达式) // 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;  
\}

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70]: /images/20221123/8631dd396e6d4ae89a403281a986edfb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1]: /images/20221123/1d00b574ab5a48d889c236eddcb6d39a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2]: /images/20221123/7f482fc10cc7494aac8d988477c30f70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3]: /images/20221123/a0d89a902fec42e08b24bca37db2e290.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4]: /images/20221123/9832a4fc74d0414db9ab74a9fd234a3c.png