C++从入门到精通第二章（基本数据类型、运算符和表达式）

Zevalin爱灰灰

已于 2024-03-10 14:40:03 修改

阅读量955

点赞数 19

分类专栏： C++从入门到精通文章标签： c++ 开发语言

于 2024-02-18 15:16:17 首次发布

本文链接：https://blog.csdn.net/Zevalin/article/details/136152255

版权

C++从入门到精通专栏收录该内容

20 篇文章 4 订阅

订阅专栏

写在前面：

本系列专栏主要介绍C++的相关知识，思路以下面的参考链接教程为主，大部分笔记也出自该教程，笔者的原创部分主要在示例代码的注释部分。
除了参考下面的链接教程以外，笔者还参考了其它的一些C++教材（比如计算机二级教材和C语言教材），笔者认为重要的部分大多都会用粗体标注（未被标注出的部分可能全是重点，可根据相关部分的示例代码量和注释量判断，或者根据实际经验判断）。
由于C++基本继承了C语言的所有内容，建议读者先阅读C语言系列的专栏，有一些重点是仅在C语言系列专栏中有介绍的（比如二级指针、预处理等）。
如有错漏欢迎指出。

参考教程：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili

一、C++语言的基本数据类型

1、数据类型概述

（1）C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存。

（2）C++中的数据类型大体可以分成三类：基本类型、导出类型和用户定义类型。

①基本类型是由C++语言预先定义好的数据类型，包括逻辑型、字符型、整型、浮点型和空值型。

②导出类型是由某种已知类型构造出来的数据类型，包括数组、指针和引用。

③用户定义类型是指必须由用户给出的具体定义后才能使用的数据类型，包括枚举类型和类类型。

2、基本类型

（1）逻辑型：

①逻辑型用关键字bool表示，因此又称为bool型（布尔型）。

②逻辑型的取值只包含true和false，它们都是C++关键字，其中true对应整数1，表示逻辑真；false对应整数0，表示逻辑假。

③布尔类型数据占用1字节（Byte），即8位（bit）空间。

（2）字符型：

①字符型用关键字char表示，因此又称为char型。

②字符型的取值范围是全部基本字符以及ASCII码集或扩充ASCII码集对应的全部符号。

③字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。

ASCII 码大致由以下两部分组成：

[1]ASCII非打印控制字符：ASCII表上的数字0-31分配给了控制字符，用于控制像打印机等一些外围设备。

[2]ASCII打印字符：数字32-126分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

④字符型数据占用1字节（Byte），即8位（bit）空间。

⑤字符型与整型关系密切，字符集与单字节整数存在对应关系（ASCII码），例如字母a的ASCII码值是97，因此还可以将字符型看作是用来表示单字节整数的整型，字符型在整数中的取值范围是-128~127（有符号字符型）或0~255（无符号字符型）。

（3）整型：

①整型用关键字int表示，因此又称为int型，它是C++中最常用的数据类型，如0、-114、514等整数都是整型数据。

②在16位计算机中，整型变量占2个字节；在32位计算机中，整型变量占4个字节。

③由于计算机的存储空间有限，因此整型数据的取值范围是计算机所能表示的全部整数，例如在16位计算机中，有符号短整型数的取值范围是-32768~32767（共 $2^{16}$ 个取值）。

④如果超出了相应数据类型的取值范围，那么最后运行时结果会出现错误。

（4）浮点型：

①浮点型包括单精度型和双精度型两种，单精度型用关键字float表示（float型），双精度型用关键字double表示（double型）。

②浮点型对应着数学中实数的概念，即带有小数点的数。

③float型数据一般占用4个字节，即32位空间；double型数据一般占用8个字节，即64位空间。

④C++中的浮点数可以采用尾数加阶码的表示形式，其中单精度型的取值范围是-3.4E38~3.4E38，但不能超过7位有效数字，如果有效数字超出7位，则舍去第7位以后的数字；双精度型的取值范围是-1.7977E308~1.7977E308，但不能超过15位有效数字，如果有效数字超出15位，则舍去第15位以后的数字。

（5）空值型：

①空值型用关键字void表示，因此又称为void型。

②空值型的取值为空。

③C++中不存在void型的常量或变量。

④所有函数说明都必须指明返回值类型，没有返回值的函数应说明为void类型。

⑤void类型还可以用来声明一个指针变量，其中指针变量所指向的数据类型尚不确定。

3、基本类型的派生类型

（1）C++中，基本类型的字长及其取值范围可以放大和缩小，改变后的类型就叫做基本类型的派生类型。

（2）派生类型声明符由基本类型关键字char、int、float、double前面加上类型修饰符组成，类型修饰符包括：

①short：短类型，缩短字长。（不能修饰char类型）

②long：长类型，加长字长。（不能修饰char类型）

③signed：有符号类型，取值范围包括正负值。（能修饰char类型）

④unsigned：无符号类型，取值范围只包括正值。（能修饰char类型）

（3）一般变量默认为有符号类型；char类型同样可以分为有符号类型和无符号类型。

（4）实际上还可以使用派生类型名的简化形式，其效果与完整的派生类型名等价，例如可以用long来代替long int，用unsigned long来代替unsigned long int。

二、常量

1、常量概述

（1）常量是指在程序执行过程中值不改变的量，有字面常量和符号常量两种表示形式。

（2）字面常量根据书写形式进行区分，例如15（整型常量）、-2.26（实型常量）、’a’（字符常量）、”hello”（字符串型常量）都是字面常量，每个字面常量的字面本身就是它的值。

（3）符号常量是一个标识符，在程序中必须遵循“先声明，后使用”的原则。

2、逻辑常量

（1）逻辑类型只包含true和false两个取值。

（2）对于逻辑表达式“x==y”，如果x与y相等（也就是逻辑表达式成立），则表达式的值为true，否则为false。

（3）逻辑常量主要用在逻辑运算中。此外，由于逻辑值对应着整数1或0，所以它也能够像其它整数一样出现在表达式中参与各种整数运算。

3、字符常量

（1）字符常量简称字符，它以单引号作为起止符号，中间有一个或若干个字符（由若干个字符组成的字符序列都是以“\”开头的字符序列，该序列对应转义字符，它不但可以作为字符常量，还可以同其它字符一样出现在字符串中）。

转义字符	字符值	输出结果
\’	一个单撇号（‘）	输出单撇号字符’
\”	一个双撇号（“）	输出双撇号字符”
\?	一个问号（?）	输出问号字符?
\\	一个反斜线（\）	输出反斜线字符\
\a	警告	产生声音或视觉信号
\b	退格	将光标当前位置后退一个字符
\f	换页	将光标当前位置移到下一页的开头
\n	换行	将光标当前位置移到下一行的开头
\r	回车	将光标当前位置移到本行的开头
\t	水平制表符	将光标当前位置移到下一个Tab位置
\v	垂直制表符	将光标当前位置移到下一个垂直制表符对齐点
\o、\oo或\ooo 其中o代表一个八进制数字	与该八进制码对应的ASCII字符	与该八进制码对应的字符
\xh[h…] 其中h代表一个十六进制数字	与该十六进制码对应的ASCII字符	与该十六进制码对应的字符

（2）无论字符常量包含一个还是多个字符，每个字符常量都只能表示一个字符。

（3）一个字符用于显示输出时，将输出字符本身或体现出相应的控制功能；当它在表达式中参加整数运算时，将使用它的ASCII码值。

4、整型常量

（1）整型常量就是整型常数，简称整数，它有十进制、八进制和十六进制3种表示方式。

①十进制整数以正号（+）或负号（-）开头，由首位非0的一串十进制数字组成。（若以正号开头则为正数，若以负号开头则为负数，若省略正负号则默认为正数）

②八进制整数以数字0开头，后面接若干个八进制数字（借用十进制数字的0~7），整数前面不带正负号，全部默认为正数。（当一个八进制整数大于等于0同时小于017777777777时，称为整型常量；当大于等于020000000000同时小于037777777777时，称为无符号整型常量）

③十六进制整数以数字0和字母x（大小写均可）开头，后面接若干个十六进制数字（借用十进制数字的0~9，字母A~F或a~f），整数前面不带正负号，全部默认为正数。

（2）对于任一种进制的整数，若后缀为字母u（大小写均可），则规定它为一个无符号整型数；若后缀字母为l（大小写均可），则规定它为一个长整型数。

5、实型常量

（1）实型常量简称实数，对应着数学中的实数概念，有十进制的定点表示和浮点表示两种表示方法。

①定点表示的实数简称定点数，即以小数形式表示实数。

②浮点表示的实数简称浮点数，即以指数形式表示实数。浮点表示的实数由一个十进制整数或定点数后接一个字母E（大小写均可）和一个1至3位的十进制整数组成，字母E之前的部分称为该浮点数的尾数，之后的部分称为该浮点数的指数，该浮点数的值就是它的尾数乘以10的指数幂。

（2）对于一个浮点数，若将它尾数中的小数点调整到最左边第一个非零数字的后面，则称它为规格化（或标准化）浮点数。

（3）实型常量分为单精度（float）、双精度（double）和长双精度（long double）三类。

（4）对于一个定点数或浮点数，C++自动按一个双精度数来存储，若在一个定点数或浮点数之后加上字母F（大小写均可），则自动按一个单精度数来存储。

6、枚举常量

（1）枚举常量是枚举类型中定义的值，即枚举值。枚举类型属于用户定义类型，用关键字enum表示，因此又称为enum类型。

（2）声明枚举类型的语法格式为：

enum <类型名> { <枚举值表> };

①enum是关键字，指出要定义的是枚举类型。

②类型名是标识符，即由用户给出的具体枚举类型名。

③枚举值表包含多个枚举值，它们用逗号分隔开，每个枚举值就是一个枚举常量，它有两种定义形式，如下图所示。

（3）关于enum类型的几点说明：

①一个enum类型实际上是int类型的一个子集，其每一个枚举值代表一个整数。

②n个枚举值全部未赋常量值时，它们从前至后分别与整数0、1、…、n-1对应。

③若第i个枚举值赋常量值为m，则其未赋常量值的后续枚举值分别与整数m+1、m+2、…对应，直到下一个赋了值的枚举值或结束，因此，为枚举值所赋的整型常量值应从前至后递增。

④枚举类型的声明也可作为成组声明若干整型符号常量的方法。

7、C++定义常量的两种方式

（1）#define 宏常量：#define 常量名常量值

通常在文件上方定义，表示一个常量，不可修改

（2）const修饰的变量（符号常量）：const 数据类型常量名 = 常量值

通常在变量定义前加关键字const，修饰该变量为常量，不可修改

三、变量

1、变量的定义

（1）变量是程序中用于存储信息的单元，它对应于某个内存空间。在定义变量时，需要说明变量的名字和数据类型，也就是给一段指定的内存空间起名，方便操作这段内存。

（2）语法：

[<存储类>] <类型名> <变量名> [= <初值表达式>]

①存储类有四种，它们分别是auto、register、static、extern，默认为auto（最常用的也是auto）。

②类型名为已存在的一种数据类型名称，如char、int、float等。

③变量名是用户定义的一个标识符，用来表示一个变量，该变量可以通过后面的可选项赋予一个值，称为给变量赋初值，也叫做对变量进行初始化，若变量名后面不带初值表达式，则不为变量赋予任何值，此时的变量值不确定。

2、全局变量和局部变量

（1）全局变量：

①全局变量是在所有函数定义、类定义和程序块之外声明的变量。

②声明全局变量时如果在程序中不对它进行专门的初始化，该变量会被系统自动初始化为0。

③在程序的任何一个函数、类或程序块之内均可以访问全局变量。

（2）局部变量：

①局部变量是在某个函数定义、类定义或程序块之内声明的变量。

②局部变量只能在声明它的函数、类或程序块中被访问。

3、生存期与作用域

（1）生存期是指从一个变量被声明且分配了内存开始，直到该变量声明语句失效，它占用的内存空间被释放为止。

（2）一个全局变量的生存期从它被声明开始，直到程序结束；一个局部变量的生存期从它被声明开始，直到包含它的最近的一个程序块结束。

（3）作用域是指变量名可以代表该变量存储空间的范围，一般情况下，变量的作用域与其生存期一致，但由于C++允许在程序的不同部分为不同变量取同一名字，因此一个变量名的作用域可能小于其生存期。

4、变量的存储类属性

（1）auto变量：用关键字auto声明的局部变量称为自动变量。auto是变量声明时的默认存储类别，即在变量定义时，如果不显式标明存储类别，则系统自动按auto变量处理。auto变量所占用存储空间的分配和释放工作将由系统自动完成。

（2）register变量：用关键字register声明的局部变量称为寄存器变量。register变量可能以寄存器作为其存储空间，声明寄存器变量时，关键字register的作用只能是建议（而不是强制）系统使用寄存器，当寄存器的空间不够用时，该变量仍然按照自动变量处理。

（3）static变量：用关键字static声明的变量称为静态变量。任何静态变量的生存期将延续到整个程序的终止。与全局变量一样，为静态变量分配的存储空间在整个程序运行过程中不再被释放；如果静态变量未被赋初值，系统将自动为其赋初值为0。

（4）extern变量：用关键字extern声明的变量称为外部变量。变量一旦被声明为外部变量，系统就不必像一般变量那样为其分配内存，因为该变量已在这一局部的外面被定义。外部变量一般用于多个文件组成的程序中，有些变量在多个文件中被声明，但指的是同一个变量，表明某一个变量为外部变量可以避免为其重复分配内存。

5、typedef类型说明

（1）使用typedef可以为已有类型名定义一个新类型名（原名仍旧可以正常使用）。

（2）举例：

四、运算符和表达式

1、运算符和表达式的概念

（1）C++中的运算符又称为操作符，是用来对数据进行运算的符号，运算中所需要的数据称为操作数或运算分量。

（2）由一个或多个操作数与操作符连接而成的有效运算式称为表达式，表达式还能以运算分量的角色（任何一个表达式都有一个运算结果，这个结果可以充当运算分量的角色）出现在运算中从而组成新的表达式。

2、赋值运算

（1）赋值运算是一种双目运算，其形式为：

<变量名> = <表达式>

①右运算分量为一个表达式，“=”为赋值运算符，左运算分量为与右运算分量类型相同的变量。

②赋值运算的具体操作为：先计算右端表达式的值，然后把该值赋给左端变量。

（2）由赋值符号连接左端变量和右端表达式而构成的式子称为赋值表达式，每个赋值表达式都有一个值，这个值就是通过赋值得到的左端变量的值。（对于任一种赋值运算，其赋值号或复合赋值号左边必须是一个左值，左值是指具有对于的可由用户访问的存储单元，并且能够由用户改变其值的量，一个赋值表达式的结果实际上是一个左值）

（3）通常在一个赋值表达式中，赋值号两边的数据类型是相同的，当两边的数据类型不同时，则在赋值前会自动把右边表达式的值转换为与左边变量类型相同的值，然后再把这个值赋给左边变量。（当把一个实数值赋给一个整型量时，将丢失小数部分，获得的只是整数部分）

（4）在一个赋值表达式中可以使用多个赋值号实现给多个变量赋值的功能。（赋值号的运算顺序是从右向左）

（5）赋值号也可以使用在常量和变量的声明语句中，用于给符号常量和变量赋初值，但这里的赋值号只起到赋初值的作用，并不构成赋值表达式。

（6）C++中还有许多复合赋值运算符，它们的含义为：将右边表达式的值同左边变量的值进行相应运算后，再把这个运算结果赋给左边的变量，该复合赋值表达式的值也就是保存在左边变量的值。

3、算术运算符和算术表达式

（1）算术运算符是指int型、float型、double型（也包括char型）的数值类数据计算后，得到同一类型数据的运算，算术运算中所使用的运算符称为算术运算符。

（2）由算术运算符（包括单目和双目）连接运算分量而组成的式子称为算术表达式，每个算术表达式的值为一个数值，其类型按照以下规则确定：

①当参加运算的两个运算分量均为整型时（具体类型可以不同，比如一个为int型，另一个为char型），其运算结果为int型。

②当参加运算的两个运算分量中至少有一个是单精度型，并且另一个不是双精度型时，则运算结果为float型。

③当参加运算的两个运算分量中至少有一个是双精度型时，则运算结果为双精度型。

（3）举例：

①例1：

#include<iostream>
using namespace std;

int main() {

	//加减乘除
	int a1 = 10;  //a1是整数
	int b1 = 4;   //b1是整数

	cout << a1 + b1 << endl;  //加法
	cout << a1 - b1 << endl;  //减法
	cout << a1 * b1 << endl;  //乘法
	cout << a1 / b1 << endl;  //除法
	//（两个整数做除法，结果小数部分舍去，即使是五也不入；另外除数不能为0）

	double d1 = 0.5;
	double d2 = 0.22;
	double d3 = 0.25;
	cout << d1 / d2 << endl;  //两个小数做除法，结果可以是小数
	cout << d1 / d3 << endl;  //当然，能整除的话结果为整数

	system("pause");

	return 0;
}

②例2：

#include <iostream>
using namespace std;

int main() {

	//取模（取余）运算的本质就是求余数，当然这仅限于整数间的运算
	int a1 = 10;
	int b1 = 3;
	cout << a1 % b1 << endl;  //（10÷3的余数为1）
	int a2 = 10;
	int b2 = 20;
	cout << a2 % b2 << endl;  //（10÷20的余数为10）
	//取模运算也是基于除法的，所以除数也不能为0

	system("pause");

	return 0;
}

③例3：

#include <iostream>
using namespace std;

int main() {

	//1、前置递增
	int a = 10;
	++a;  //让变量+1的操作
	cout << "a =" << a << endl;

	//2、后置递增
	int b = 10;
	b++;  //让变量+1的操作
	cout << "b =" << b << endl;

	//3、前置和后置的区别（递减同理）
	//前置递增：先让变量+1，再进行表达式运算
	int a2 = 10;
	int b2 = ++a2 * 10;
	cout << "a2 =" << a2 << endl;
	cout << "b2 =" << b2 << endl;
	//后置递增：先进行表达式运算，再让变量+1
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << "a3 =" << a3 << endl;
	cout << "b3 =" << b3 << endl;

	system("pause");

	return 0;
}

4、关系运算符和关系表达式

（1）C++提供了六种关系运算符（如下图所示），它们都是双目运算符（也就是有两个运算分量），运算结果为逻辑型值true（对应整数1）或false（对应整数0）。

（2）由一个关系运算符连接前后两个数值表达式而构成的式子称为关系表达式，简称关系式，当关系式成立时，其计算结果为逻辑值真（true），否则为逻辑值假（false）。

（3）举例：

#include <iostream>
using namespace std;

int main() {

	//比较运算符
	// ==
	int a = 10;
	int b = 20;
	cout << (a == b) << endl;  //括号的作用是为了先让表达式“a == b”进行运算

	// ！=
	cout << (a != b) << endl;

	// >
	cout << (a > b) << endl;

	// <
	cout << (a < b) << endl;

	// >=
	cout << (a >= b) << endl;

	// <=
	cout << (a <= b) << endl;

	system("pause");

	return 0;
}

5、逻辑运算符和逻辑表达式

（1）C++提供了三种逻辑运算符，其中“！”是单目运算符（也就是只有一个运算分量），“&&”和“||”是双目运算符。

（2）逻辑运算的运算分量是逻辑型数据（逻辑常量、逻辑变量、关系表达式等都是逻辑型数据），由逻辑型数据和逻辑运算符连接而成的式子称为逻辑表达式，简称逻辑式。一个数值表达式也可以作为逻辑型数据使用，当值为0时则默认是逻辑值false，当值为非0时则默认为是逻辑值true。

（3）举例：

①例1：

#include <iostream>
using namespace std;

int main() {

	//逻辑运算符---非  ！（真变假，假变真）
	int a = 10;
	cout << !a << endl;
	//只要是非0的值都是真值，非真值即假，也就是0
	cout << !!a << endl;
	//!a为0，非0即真值，默认真值取1

	system("pause");

	return 0;
}

②例2：

#include <iostream>
using namespace std;

int main() {

	//逻辑运算符---与  &&（同真为真，其余为假）
	int a = 10;
	int b = 10;
	cout << (a && b) << endl;
	//两个数都非零，即都是真值，结果是默认真值1
	a = 0;
	cout<< (a && b) << endl;
	//一个数为0，结果就为0
	b = 0;
	cout << (a && b) << endl;
	//两个数都为0，结果必为0

	system("pause");

	return 0;
}

③例3：

#include <iostream>
using namespace std;

int main() {

	//逻辑运算符---或  ||（同假为假，其余为真）
	int a = 10;
	int b = 10;
	cout << (a || b) << endl;
	//两个数都非零，即都是真值，结果是默认真值1
	a = 0;
	cout<< (a || b) << endl;
	//一个数不为0，结果为默认真值1
	b = 0;
	cout << (a || b) << endl;
	//两个数都为0，结果才为0

	system("pause");

	return 0;
}

6、位运算符

（1）C++提供了六种位运算符：

①“&”是按位与运算符，它将两个运算分量的对应二进制位进行与操作，其中0和0与得0、0和1与得0、1和0与得0、1和1与得1。

②“|”是按位或运算符，它将两个运算分量的对应二进制位进行或操作，其中0和0或得0、0和1或得1、1和0或得1、1和1或得1。

③“^”是按位异或运算符，它将两个运算分量的对应二进制位进行异或操作，其中0和0异或得0、0和1异或得1、1和0异或得1、1和1异或得0。

④“>>”是按位右移运算符，由于右移的位数为右边运算分量的值，所以右边运算分量的值必须是一个整数。

⑤“<<”是按位左移运算符，由于左移的位数为右边运算分量的值，所以右边运算分量的值必须是一个整数。

⑥“~”是按位取反运算符，它将运算分量的对应二进制数的每一位进行取反操作，其中0取反得1、1取反得0。

（2）举例：

表达式	表达式的二进制值
X = 24	00011000
Y = 36	00100100
X << 2	01100000
Y >> 3	00000100
~X	11100111
X & Y	00000000
X \| Y	00111100
X ^ Y	00111100

7、sizeof运算符

（1）使用关键字sizeof可以进行字长提取操作，因此sizeof运算符又称为字长提取符，它的使用格式如下所示，其中运算分量既可以是一个类型名，也可以是一个变量名。

sizeof(<运算分量>)

（2）字长提取运算的结果为一个整数，该整数表示指定的类型或变量的字节长度，即在内存中占用的字节（Byte）数。

#include<iostream>
using namespace std;

int main() {

	//整型： short (2)  int (4)  long (4)  long long (8)
	//可以利用sizeof求出数据类型占用内存大小
	//语法： sizeof（数据类型 /变量 ）

	short num1 = 10;
	cout << "short占用的内存空间为：" << sizeof(num1) << endl;
	cout << "short占用的内存空间为：" << sizeof(short) << endl;
	cout << "int占用的内存空间为：" << sizeof(int) << endl;

	system("pause");

	return 0;
}

8、条件运算符

（1）条件运算是C++中唯一的三目运算，与其对应的运算符“?:”称为条件运算符，条件运算符的使用格式为：

<表达式1> ? <表达式2> : <表达式3>

（2）当计算由条件运算符构成的表达式时，首先计算<表达式1>，若<表达式1>的值非0，则计算出<表达式2>的值，并用这个值作为整个表达式的值；若<表达式1>的值为0，则计算出<表达式3>的值，并用这个值作为整个表达式的值。

（3）举例：

①例1：

#include<iostream>
using namespace std;

int main() 
{
	int a = 1;
	int b = 2;

	int x;
	x = a > b ? a : b;  //如果a>b，则x被赋a的值，否则被赋b的值

	cout << x << endl;

	system("pause");

	return 0;
}

②例2：

#include<iostream>
using namespace std;

int main() {

	//选择结构 三目运算符
	//创建三个变量，将a和b做比较，将变量大的值赋值给变量c
	int a = 10;
	int b = 20;
	int c = 30;

	c = (a > b ? a : b);  //a>b不成立，返回的是变量b，这时b的值会赋给c
	cout << "c= " << c << endl;

	//在C++中，三目运算符返回的是变量，可以继续赋值
	(a > b ? a : b) = 100;  //a>b不成立，返回的是变量b，这时会给b赋值100
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	system("pause");

	return 0;
}

9、逗号运算符

（1）C++中使用逗号运算符指明对多个表达式进行顺序求值，其使用格式为：

<表达式1> , <表达式2> , … , <表达式n>

（2）上式中每个逗号都称为逗号运算符，整个式子称为逗号表达式，它的求值步骤为：从左向右依次计算<表达式1>、<表达式2>、… 、<表达式n>的值，然后将<表达式n>（即最右端表达式）的值作为整个逗号表达式的值。

10、圆括号运算符

（1）圆括号可用于函数调用，其格式为：

<函数名>(<实参列表>)

（2）圆括号可用于强制类型转换，其格式为：

(<类型名>) <表达式>

（3）圆括号可用于类型构造（在功能上等价于强制类型转换），其格式为：

<类型名> (<表达式>)

#include<iostream>
#include<math.h>
using namespace std;

int main() 
{
	int a = 1;
	int b = 2;

	//①函数调用
	float x = sqrt(100);

	//②强制类型转换
	cout << a << (double)a << endl;  //将a强制转换为double型

	//③类型构造
	char c = char(97);  //将97构造为char型变量
	cout << c << endl;

	system("pause");

	return 0;
}

11、优先级和结合性

优先级	运算符	功能	用法	结合性
1	::	类域	class_name::member	左结合
1	::	全局域	::name	左结合
2	.	成员选择	object.member	左结合
	->	成员选择	pointer->member
	[ ]	下标	pointer[expr]
	( )	函数调用	expr(expr_list)
	( )	类型构造	type(expr_list)
	++	后缀递增	lvalue++	右结合
	--	后缀递减	lvalue--	右结合
3	sizeof	变量长度	sizeof expr	右结合
	sizeof	类型长度	sizeof(type)
	++	前缀递增	++lvalue
	--	后缀递增	--lvalue
	~	按位取反	~expr
	!	逻辑非	!expr
	-	单目减（负号）	-expr
	+	单目加（正号）	+expr
	&	取地址	&expr
	*	值引用	*expr
	new	动态分配	new type
	delete	变量释放	delete pointer
	delete	数组释放	delete [] poniter
	( )	强制类型转换	(type)expr
4	.*	指向成员选择	object. * pointer_to_member	左结合
4	->*	指向成员选择	pointer-> * pointer_to_member	左结合
5	*	乘	expr * expr	左结合
	/	除	expr / expr
	%	取余（取模）	expr %expr
6	+	加	expr + expr	左结合
6	-	减	expr - expr	左结合
7	<<	按位左移	expr << expr	左结合
7	>>	按位右移	expr >> expr	左结合
8	<	小于	expr < expr	左结合
	<=	小于等于	expr <= expr
	>	大于	expr > expr
	>=	大于等于	expr >= expr
9	==	等于	expr == expr	左结合
9	!=	不等于	expr != expr	左结合
10	&	按位与	expr & expr	左结合
11	^	按位异或	expr ^ expr	左结合
12	\|	按位或	expr \| expr	左结合
13	&&	逻辑与	expr && expr	左结合
14	\|\|	逻辑或	expr \|\| expr	左结合
15	?:	条件表达式	expr ? expr : expr	右结合
16	=	赋值	lvalue = expr	右结合
	*=	乘赋值	lvalue *= expr
	/=	除赋值	lvalue /= expr
	%=	取余赋值	lvalue %= expr
	+=	加赋值	lvalue += expr
	-=	减赋值	lvalue -= expr
	<<=	按位左移赋值	lvalue <<= expr
	>>=	按位右移赋值	lvalue >>= expr
	&=	按位与赋值	lvalue &= expr
	\|=	按位或赋值	lvalue \|= expr
	^=	按位异或赋值	lvalue ^= expr
17	,	逗号	expr , expr	左结合