C++编程工具
程序开发基本概念
- 源程序
源程序就是我们用各种语言写的程序,我们常说写代码其实就是在写源程序。源程序可以是汇编语言或者高级语言等其他语言所写。 - 目标程序
目标程序是经过翻译之后生成的程序,可以是机器语言表示的,也可以是汇编语言或其他中间语言表示的。我们写程序编译之后的obj文件就是目标程序。目标程序理论说应该能运行,但是程序运行离不开操作系统的支持,它必须经过装载和链接,生成可执行程序(exe文件)才能运行。 - 翻译程序
翻译程序就是把源程序翻译成目标程序的程序。它有三种类型:汇编程序、编译程序和解释程序。
汇编程序是把用汇编语言程序翻译成目标程序的程序。编译程序是把高级语言程序翻译成目标程序的程序,C++是高级语言,需要编译程序。解释程序也是将高级语言翻译成目标程序,但它是输入一句,翻译一句,执行一句,直到整个源程序被翻译执行完毕,效率比较低。
程序工具VS

若要使用MFC,则需要在安装时在“单个组件”选项中,找到并勾选适用于最新的v142生成工具的C++ MFC (x86和x64)。
界面简介
- 菜单栏:我们常用的是File,View和Debug菜单下的菜单项。工具栏各项其实在菜单栏都有与它们对应的菜单项,功能是一样的。
- 左侧面板可以放多个视图,我这里放了解决方案浏览器、类视图、资源视图和Git,解决方案浏览器中我们可以看到所有头文件和源文件构成的树,头文件就是.h后缀的文件,源文件就是.cpp后缀的文件,类视图中显示了每个工程的每个类,也是树状结构,在解决方案浏览器或类视图中双击每一项,中间区域都会打开相应的文件或者到类的位置。资源视图中显示了界面工程中使用的一些界面资源。
- 中间区域默认是打开start page,打开一个工程后我们在左侧面板上双击某项时,中间区域会出现相应的界面。
- 右侧面板上有个Toolbox,是在界面工程中用来往界面资源模板上添加控件的,里面包含了各种控件,直接拖到模板上就行了。底侧还有几个标签,其中一个是output,这是输出视图,用来输出程序运行信息和我们程序中写的一些调试信息,还有一个Find Result视图,用来显示我们搜索任何字母或单词的结果。
项目创建
File->New->Project项可以创建一个工程,也可以在start page中点击New Project…,然后出现的New Project窗口中有多个工程类型可以选择。
- Win32 Console Application是Win32控制台程序:一个没有应用程序界面的只有Dos命令行界面的工程,它的入口是main函数
- MFC Application是MFC应用程序,可以建立以开发界面程序
- Win32 Project是Win32程序:Win32 Project的入口是WinMain函数(代表不同编译环境)
- Empty Project是空程序
- MFC DLL用来建立生成动态链接库的工程
一个解决方案中可以包含多个工程,你可以把它理解为多个有关系或者没关系的工程的集合,有时把多个工程放到一个解决方案里调试起来很方便。
工具栏上有个下拉列表框,它包含有Debug、Release和Configuration Manager,选择Debug时为调试模式,生成的可执行程序中包含调试信息,我们可以调试并清楚的看到变量值,选择Release时生成的可执行程序中不含调试信息,在设置断点后看到的变量值可能不准确。
项目调试
- Debug->Start Debugging(快捷键是F5)用来开始调试
- Debug->Toggle Breadpoint(快捷键是F9)用来设置断点,设置断点后然后开始调试,程序运行到断点时会停下来,我们用鼠标放到断点处的各个变量上时可以看到当时这些变量的值
- Debug->Start Without Debugging(快捷键是ctrl+F5)表示不调试直接运行,也就是到断点处也不会停止运行
- Debug->Step Into(快捷键是F11)用来单步执行,遇到子函数就进入并且继续单步执行
- Debug->Step Over(快捷键是F10)也是单步执行,但在单步执行时,在函数内遇到子函数时不会进入子函数内单步执行,而是将子函数整个执行完而跳到下一步,也就是把子函数整个作为一步。
帮助文档
帮助菜单下“技术支持”(快捷键是F1)
C++数据类型
C++是从C中发展来的,可以兼容C。所以C++的一些基本语法跟C几乎是一样的。
C++程序基本结构
#include <iostream.h>
void main(void)
{
cout << "Hello world! \n";
}
- 头文件
#include叫做编译指令,用来包含一些文件。这里包含的iostream.h是C++标准库里的文件,大家可以直接用,它声明了输入输出的有关信息。这类文件常放在程序开始的地方,所以叫做头文件。 - 函数体
main是主函数名,函数体用一对大括号括住。函数是C++程序里最小的功能单位。C++程序里必须有且只能有一个main函数,它是程序执行的入口,就是从它开始执行。main函数前的void表示此函数没有返回值,后面的void表示没有参数。cout<<“Hello! \n”;是条语句,每条语句由分号结束。cout是C++标准库里预定义的对象,它的信息就放在之前包含的头文件iostream.h中,它是一个输出流对象,用操作符<<将后面的字符串输出到标准输出设备,一般是显示器。
C++符号
C++语言的字符集由下述字符构成:
- 英文字母:A-Z,a-z;
- 数字字符:0~9;
- 特殊字符:空格 ! # % ^ & * _ + = - ~ < > / \ ’ " ; . , () [] {}
关键字
关键字是C++预定义的一些单词,我们定义变量常量时是不能使用的。
auto bool break case catch char class const const_case continue default delete do double dynamic_cast else enum explicit extern false float for friend goto if inline int long mutable namespace new operate private protected public register reinterpret_cast return short signed sizeof static static_cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile while
1. 基本类型与值 (Basic Types & Values)
| 关键字 | 含义 | 示例 |
|---|---|---|
bool | 布尔类型。只有两个值:true (真) 和 false (假)。 | bool isReady = true; |
char | 字符类型。通常占用 1 个字节,用于存储单个字符或小整数。 | char ch = 'A'; |
int | 整型。通常是机器上最自然、最高效的整数类型。 | int age = 30; |
float | 单精度浮点型。用于存储带小数的数字,精度较低(约6-7位有效数字)。 | float pi = 3.14f; |
double | 双精度浮点型。用于存储带小数的数字,精度更高(约15-17位有效数字),是默认的浮点类型。 | double price = 19.99; |
void | 空类型。表示“没有类型”。用于函数返回值(表示无返回值)和指针(表示通用指针)。 | void myFunction() { ... } |
true | 布尔值“真”。 | if (isReady == true) { ... } |
false | 布尔值“假”。 | bool hasError = false; |
2. 类型修饰符 (Type Modifiers)
| 关键字 | 含义 | 示例 |
|---|---|---|
short | 短整型。通常比 int 占用更少的内存。 | short distance = 100; |
long | 长整型。通常比 int 占用更多的内存。 | long largeNumber = 100000L; |
signed | 有符号类型。可以表示正数、负数和零。 | signed int temperature = -5; |
unsigned | 无符号类型。只能表示非负数。 | unsigned int count = 10; |
const | 常量。修饰的变量其值不能被修改。 | const double PI = 3.14159; |
volatile | 易变的。告诉编译器该变量的值可能会在程序之外被改变,阻止编译器进行某些优化。 | volatile int* hardwareRegister = ...; |
mutable | 可变的。允许在 const 成员函数中修改 mutable 成员变量。 | class Foo { mutable int cache; ... }; |
3. 控制流 (Control Flow)
| 关键字 | 含义 | 示例 |
|---|---|---|
if | 条件判断。如果条件为真,则执行其代码块。 | if (score > 90) { ... } |
else | 否则。与 if 或 if-else if 搭配使用,当所有前面的条件都为假时执行。 | if (a > b) { ... } else { ... } |
switch | 多分支选择。根据一个表达式的值,从多个 case 中选择一个执行。 | switch (grade) { case 'A': ...; break; } |
case | switch 中的一个分支。 | (见上) |
default | switch 中的默认分支。如果没有任何 case 匹配,则执行 default。 | (见上) |
for | 循环。通常用于已知循环次数的场景。 | for (int i = 0; i < 10; ++i) { ... } |
while | 循环。当条件为真时,持续执行循环体。 | while (isRunning) { ... } |
do | do-while 循环。先执行一次循环体,然后再判断条件。 | do { ... } while (condition); |
break | 跳出循环或 switch。立即终止并跳出当前的循环或 switch 语句。 | for (...) { if (done) break; } |
continue | 跳过本次循环。立即结束本次循环,开始下一次循环。 | for (...) { if (skip) continue; ... } |
return | 从函数返回。终止函数的执行,并可返回一个值给调用者。 | int add(int a, int b) { return a + b; } |
goto | 无条件跳转。直接跳转到函数内的一个标签。不推荐使用,会使代码结构混乱。 | goto error_handling; ... error_handling: ... |
4. 函数、类与对象 (Functions, Classes & Objects)
| 关键字 | 含义 | 示例 |
|---|---|---|
class | 定义类。定义一个包含数据成员和成员函数的用户自定义类型。 | class Person { public: std::string name; }; |
struct | 定义结构体。与 class 类似,但默认访问权限为 public。通常用于封装数据集合。 | struct Point { int x; int y; }; |
union | 定义联合体。所有成员共享同一块内存空间,同一时间只有一个成员有效。 | union Data { int i; float f; }; |
enum | 定义枚举。创建一组命名的整型常量。 | enum Color { RED, GREEN, BLUE }; |
operator | 运算符重载。定义或改变运算符对自定义类型的行为。 | MyClass operator+(const MyClass& a, const MyClass& b); |
this | 指向当前对象的指针。在类的成员函数中使用,代表调用该函数的对象。 | void setName(std::string n) { this->name = n; } |
friend | 友元。允许一个函数或另一个类访问当前类的 private 和 protected 成员。 | friend void print(const MyClass& obj); |
inline | 内联函数。建议编译器在调用点展开函数体,以减少函数调用开销。 | inline int max(int a, int b) { return a > b ? a : b; } |
virtual | 虚函数。在基类中声明,允许派生类重写(override),是实现多态的核心。 | virtual void draw() const; |
override | 重写。明确表示一个函数是用来重写基类中的虚函数的。(C++11) | void draw() const override; |
final | 最终。防止一个类被继承,或一个虚函数被进一步重写。(C++11) | class Base final { ... }; |
explicit | 显式构造函数。防止单参数构造函数被用于隐式类型转换。 | explicit MyClass(int n); |
5. 存储类与链接 (Storage Classes & Linkage)
| 关键字 | 含义 | 示例 |
|---|---|---|
static | 静态的。 1. 在函数内:变量只初始化一次,其生命周期贯穿整个程序。 2. 在类内:成员属于类本身,而非某个特定对象。 3. 在文件作用域:限制变量或函数的链接性为内部链接。 | static int callCount = 0; |
extern | 外部链接。声明一个变量或函数在其他文件中定义,提示编译器不要在此处分配内存。 | extern int global_variable; |
register | 寄存器变量。建议编译器将变量存储在寄存器中以提高访问速度。现代编译器优化能力很强,此关键字已基本废弃。 | register int counter; |
auto | 自动类型推断。编译器会根据初始化表达式自动推断变量的类型。(C++11 起) | auto myMap = std::map<std::string, int>(); |
decltype | 类型推导。返回一个表达式的类型。(C++11) | decltype(myVariable) anotherVariable; |
6. 内存管理 (Memory Management)
| 关键字 | 含义 | 示例 |
|---|---|---|
new | 动态内存分配。在堆(heap)上分配内存,并返回指向该内存的指针。 | int* ptr = new int; |
delete | 释放动态内存。释放 new 分配的内存,防止内存泄漏。 | delete ptr; |
new[] | 动态分配数组。 | int* arr = new int[10]; |
delete[] | 释放动态数组。必须与 new[] 配对使用。 | delete[] arr; |
7. 异常处理 (Exception Handling)
| 关键字 | 含义 | 示例 |
|---|---|---|
try | 异常处理块。包裹可能抛出异常的代码。 | try { ... } catch (...) { ... } |
catch | 异常捕获块。如果 try 块中抛出异常,catch 块会捕获并处理它。 | (见上) |
throw | 抛出异常。手动触发一个异常。 | if (error) throw std::runtime_error("Error!"); |
8. 类型转换 (Type Conversion)
| 关键字 | 含义 | 示例 |
|---|---|---|
static_cast | 静态类型转换。用于基本类型之间、相关类之间的转换。在编译时检查。 | double d = static_cast<double>(5); |
dynamic_cast | 动态类型转换。主要用于在继承层次中安全地向下转型(从基类指针/引用到派生类)。在运行时检查,失败返回 nullptr 或抛出异常。 | Derived* d = dynamic_cast<Derived*>(basePtr); |
const_cast | 常量转换。用于移除或添加 const 或 volatile 限定符。使用需谨慎。 | const_cast<char*>(myString.c_str()); |
reinterpret_cast | 重新解释转换。最危险的转换,将一种类型的指针/引用直接“重新解释”为另一种类型,不进行任何类型检查。 | int* p = reinterpret_cast<int*>(0x12345678); |
9. 其他重要关键字
| 关键字 | 含义 | 示例 |
|---|---|---|
namespace | 命名空间。用于组织代码,避免标识符(变量、函数、类名)冲突。 | namespace MyProject { ... } |
using | 1. 引入命名空间或成员。 2. 定义类型别名。 | using namespace std;using IntList = std::vector<int>; |
template | 模板。用于创建通用的函数或类。是实现泛型编程(如 STL)的基础。 | template <typename T> T max(T a, T b) { ... } |
typename | 1. 在模板中声明类型参数。 2. 告诉编译器一个依赖于模板参数的名称是一个类型。 | template <typename T> class MyClass { ... }; |
sizeof | 获取大小。返回一个类型或变量所占用的内存字节数。 | size_t size = sizeof(int); |
typeid | 获取类型信息。返回一个 std::type_info 对象,用于在运行时查询对象的类型。 | if (typeid(*ptr) == typeid(Derived)) { ... } |
private | 私有访问权限。类的 private 成员只能被类的内部成员访问。 | class Foo { private: int x; }; |
protected | 保护访问权限。类的 protected 成员可以被类的内部成员和派生类访问。 | class Foo { protected: int y; }; |
public | 公共访问权限。类的 public 成员可以被任何地方访问。 | class Foo { public: void doSomething(); }; |
标识符
标识符是我们软件开发者自己声明的单词,用来命名一些实体,比如:函数名、变量名、类名、对象名等。它的构成规则:
- 以大写字母、小写字母或下划线开头;
- 可由大写字母、小写字母、下划线或数字组成;
- 字母区分大小写,大写字母和小写字母表示不同的标识符;
- 不能用C++关键字。
文字
指在程序中用符号表示的数据,包括数字、字符、字符串和布尔文字(true和false)。
运算符
用来进行运算的符号,比如:+,-,*,/
分隔符
起分隔作用,用来分隔词法记号或程序正文,分隔符有:() {} , : ; 。 这些分隔符不进行实际的操作,只是用来构造程序
空白
编译分析代码的时候会将代码分成词法记号和空白,空白包括空格、制表符(TAB键产生的字符)、换行符(回车键产生的字符)和注释。
- 空白用来表示词法记号的开始和结束位置,其余的空格将被编译器忽略。比如int i;跟int i;是等价的。
- 注释是对代码进行必要的注解和说明,编译时不会理会注释部分,C++语言有两种注释方法:
1. 使用“/”和“*/”括起注释文字,例如,/this is a comment/;
2.使用“//”,从“//”开始直到它所在行的行尾,所有的字符都被作为注释处理,比如,// this is a comment。
C++数据类型
基本数据类型
C++的基本数据类型有bool(布尔型)、char(字符型)、int(整型)、float(浮点型,表示实数)、double(双精度浮点型)。除了bool型外,有两大类:整数和浮点数。因为char型本质上就是整型,只不过是一个字节的整数,用来存放字符的ASCII码。还有几个关键字signed和unsigned、short和long起修饰作用。
-
short修饰int时,short int表示短整型,占2个字节,这里int可以省略,也就是说short就是short int。long可以修饰int和double,long int表示长整型,占4个字节,同样int也可以省略。int在不同的编译环境中可能占的字节数不一样,大多数环境中占用4个字节。short类型固定占2个字节,long类型固定占4个字节。
-
signed和unsigned可以用来修饰char型、int型、short型和long型。signed表示有符号数,unsigned表示无符号数。有符号数以二进制补码形式存储,最高位为符号位,“0”表示正,“1”表示负。无符号整数只能是正数。char型、int型、short型和long型默认情况也就是不加修饰的情况下是有符号(signed)的。
-
bool型数据取值只能是false(假)或true(真)。它所占的字节数在不同的编译系统中可能也不一样,但大多数是占1个字节。
常量
所谓常量就是在程序运行过程中始终不会变的量,就是直接用文字表示的值,例如,1,23,true,‘B’都是常量。常量又分整型常量、实型常量、字符常量、字符串常量和布尔常量。
- 整型常量包括正整数、负整数和零。整型常量的形式有十进制、八进制和十六进制。十进制我们都知道了,八进制常量的数字必须以数字0开头,比如0324,-0123。十六进制整型常量的数字必须以0x开头,比如0x3af。
- 实型常量就是数学上的小数,有两种表示形式:一般形式和指数形式。一般形式比如:13.7,-22.5。指数形式比如:0.2E+2表示0.2*10^2。
- 字符常量是单引号括起来的一个字符,比如:‘b’,‘?’。还有一些不可显示字符,例如响铃、换行、制表符等等,C++提供了一种转义序列的表示法来表示这些字符。比如:\a表示响铃,\n表示换行,\t表示水平制表符,\b表示退格,\r表示回车,\表示字符’',"表示双引号,'表示单引号。ASCII字符常量占用1个字节。
- 字符串常量是用双引号括起来的字符序列,比如:“China”。字符串常量会在字符序列末尾添加’\0’作为结尾标记。
- 布尔常量只有两个:false(假)和true(真)。
变量
变量与常量一样也有自己的类型,在使用之前必须首先声明它的类型和名称。变量名也是标识符,因此命名规则应遵从标识符的命名规则。同一个语句中可以声明同一个类型的多个变量.
变量声明语句的形式:
数据类型 变量名1,变量名2,...,变量名n;
赋初值右两种形式:
int num=3;
int num(3);
符号常量
我们除了可以用文字表示常量以外,还可以给常量起个名字,这就是符号常量。这个符号常量就代表了那个常量。
符号常量在使用之前必须声明,跟变量相似。符号常量声明形式:
const 数据类型说明符 常量名=常量值;
数据类型说明符 const 常量名=常量值;
const float pi=3.1415926;
note:符号常量声明时必须赋初值,在其他时候不能改变它的值
使用符号常量与文字常量相比有很多好处:程序的可读性更高,我们看到这个名字就能看出它的具体意思,再就是最重要的,如果我们多个地方都用了上面那个pi常量,但后来圆周率的值精度我想改一下,只用3.14,这个时候怎么把所有的pi都换掉呢?我们只需要修改pi的声明就行了:const float pi=3.14;,但是如果使用文字常量即所有用圆周率的地方直接写的3.1415926,那么就必须全找到再换掉,这样不但麻烦而且容易漏掉。
auto
在 C++11 及以后的版本中,auto 是一个类型说明符,用于自动推导变量的类型,让编译器根据初始化表达式的类型来确定变量的类型。
- 基本用法
auto x = 42; // x 的类型为 int
auto y = 3.14; // y 的类型为 double
auto z = "hello"; // z 的类型为 const char*
std::vector<int> vec = {1, 2, 3};
auto it = vec.begin(); // it 的类型为 std::vector<int>::iterator
- 基本规则
- 初始化必须存在:auto 必须通过初始化表达式推导类型,不能单独使用。
auto a; // 错误:必须初始化
auto b = 10; // 正确
- 忽略顶层 const 和引用:
const int x = 10;
auto y = x; // y 的类型是 int(顶层 const 被忽略)
int num = 5;
int& ref = num;
auto z = ref; // z 的类型是 int(引用被忽略)
- 保留底层 const
const std::vector<int>* ptr = new std::vector<int>();
auto p = ptr; // p 的类型是 const std::vector<int>*(底层 const 保留)
- 显式指定引用或 const:
const int& cref = num;
auto& myRef = cref; // myRef 的类型是 const int&(保留 const 和引用)
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 |
关系运算符
假设变量 A 的值为 10,变量 B 的值为 20
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等,如果相等则条件为真。 | (A == B) 不为真。 |
| != | 检查两个操作数的值是否相等,如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值,如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值,如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值,如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值,如果是则条件为真。 | (A <= B) 为真。 |
逻辑运算符
假设变量 A 的值为 1,变量 B 的值为 0
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都 true,则条件为 true。 | (A && B) 为 false。 |
| 11 | 称为逻辑或运算符。如果两个操作数中有任意一个 true,则条件为 true。 | (A11 B) 为 true。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态,如果条件为 true 则逻辑非运算符将使其为 false。 | !(A && B) 为 true |
位运算符
位运算符作用于位,并逐位执行操作。&、 | 和 ^ 的真值表如下所示:
| p | q | p&q | p1q | p^q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
可用于二进制计算。
赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符,把右边操作数的值赋给左边操作数 | 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 |
| 1= | 按位或且赋值运算符 | C 1= 2 等同于 C = C |
杂项运算符
| 运算符 | 描述 |
|---|---|
| sizeof | sizeof 运算符返回变量的大小。例如,sizeof(a) 将返回 4,其中 a 是整数。 |
| Condition ? X : Y | 条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。 |
| , | 逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。 |
| .(点)和 ->(箭头) | 成员运算符用于引用类、结构和共用体的成员。 |
| Cast | 强制转换运算符把一种数据类型转换为另一种数据类型。例如,int(2.2000) 将返回 2。 |
| & | 指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。 |
| * | 指针运算符 * 指向一个变量。例如,*var; 将指向变量 var。 |
C++ 中的运算符优先级
下表将按运算符优先级从高到低列出各个运算符,具有较高优先级的运算符出现在表格的上面,具有较低优先级的运算符出现在表格的下面。在表达式中,较高优先级的运算符会优先被计算。
| 类型 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | 1 | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | 11 | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= | = |
| 逗号 | , | 从左到右 |

2169

被折叠的 条评论
为什么被折叠?



