万字长文解析C++ 基础知识！初学者必看的一篇

向右看齐 2022-12-10 14:50 152阅读 0赞

点击上方“**五分钟学算法**”，选择“星标”公众号

重磅干货，第一时间送达![format_png][]

![format_png 1][]

**来自公众号：大学计算机基础**

## C++ 注释    ##

程序的注释是解释性语句，您可以在 C++ 代码中包含注释，这将提高源代码的可读性。所有的编程语言都允许某种形式的注释。

C++ 支持单行注释和多行注释。注释中的所有字符会被 C++ 编译器忽略。

C++ 注释以 /\* 开始，以 \*/ 终止。例如：

/* 这是注释 *//* C++ 注释也可以 * 跨行 */

注释也能以 // 开始，直到行末为止。例如：

#include using namespace std;main(){   cout << "Hello World"; // 输出 Hello World     return 0; }

当上面的代码被编译时，编译器会忽略 **// prints Hello World**，最后会产生以下结果：

Hello World

在 /\* 和 \*/ 注释内部，// 字符没有特殊的含义。在 // 注释内，/\* 和 \*/ 字符也没有特殊的含义。因此，您可以在一种注释内嵌套另一种注释。例如：

/* 用于输出 Hello World 的注释cout << "Hello World"; // 输出 Hello World  */

## C++ 数据类型 ##

使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留一些空间。

您可能需要存储各种数据类型（比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。

## 基本的内置类型 ##

C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型：

<table> 
 <tbody> 
  <tr> 
   <th>类型</th> 
   <th>关键字</th> 
  </tr> 
  <tr> 
   <td>布尔型</td> 
   <td>bool</td> 
  </tr> 
  <tr> 
   <td>字符型</td> 
   <td>char</td> 
  </tr> 
  <tr> 
   <td>整型</td> 
   <td>int</td> 
  </tr> 
  <tr> 
   <td>浮点型</td> 
   <td>float</td> 
  </tr> 
  <tr> 
   <td>双浮点型</td> 
   <td>double</td> 
  </tr> 
  <tr> 
   <td>无类型</td> 
   <td>void</td> 
  </tr> 
  <tr> 
   <td>宽字符型</td> 
   <td>wchar_t</td> 
  </tr> 
 </tbody> 
</table>

一些基本类型可以使用一个或多个类型修饰符进行修饰：

*  signed
 *  unsigned
 *  short
 *  long

下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。

<table> 
 <tbody> 
  <tr> 
   <th>类型</th> 
   <th>位宽度</th> 
   <th>范围</th> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>1 个字节</td> 
   <td>-127 到 127 或者 0 到 255</td> 
  </tr> 
  <tr> 
   <td>unsigned char</td> 
   <td>1 个字节</td> 
   <td>0 到 255</td> 
  </tr> 
  <tr> 
   <td>signed char</td> 
   <td>1 个字节</td> 
   <td>-127 到 127</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>4 个字节</td> 
   <td>-2147483648 到 2147483647</td> 
  </tr> 
  <tr> 
   <td>unsigned int</td> 
   <td>4 个字节</td> 
   <td>0 到 4294967295</td> 
  </tr> 
  <tr> 
   <td>signed int</td> 
   <td>4 个字节</td> 
   <td>-2147483648 到 2147483647</td> 
  </tr> 
  <tr> 
   <td>short int</td> 
   <td>2 个字节</td> 
   <td>-32768 到 32767</td> 
  </tr> 
  <tr> 
   <td>unsigned short int</td> 
   <td>Range</td> 
   <td>0 到 65,535</td> 
  </tr> 
  <tr> 
   <td>signed short int</td> 
   <td>Range</td> 
   <td>-32768 到 32767</td> 
  </tr> 
  <tr> 
   <td>long int</td> 
   <td>4 个字节</td> 
   <td>-2,147,483,647 到 2,147,483,647</td> 
  </tr> 
  <tr> 
   <td>signed long int</td> 
   <td>4 个字节</td> 
   <td>与 long int 相同</td> 
  </tr> 
  <tr> 
   <td>unsigned long int</td> 
   <td>4 个字节</td> 
   <td>0 到 4,294,967,295</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>4 个字节</td> 
   <td>+/- 3.4e +/- 38 (~7 个数字)</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>8 个字节</td> 
   <td>+/- 1.7e +/- 308 (~15 个数字)</td> 
  </tr> 
  <tr> 
   <td>long double</td> 
   <td>8 个字节</td> 
   <td>+/- 1.7e +/- 308 (~15 个数字)</td> 
  </tr> 
  <tr> 
   <td>wchar_t</td> 
   <td>2 或 4 个字节</td> 
   <td>1 个宽字符</td> 
  </tr> 
 </tbody> 
</table>

从上表可得知，变量的大小会根据编译器和所使用的电脑而有所不同。

下面实例会输出您电脑上各种数据类型的大小。

#include <iostream>using namespace std;int main(){   cout << "Size of char : " << sizeof(char) << endl;   cout << "Size of int : " << sizeof(int) << endl;   cout << "Size of short int : " << sizeof(short int) << endl;   cout << "Size of long int : " << sizeof(long int) << endl;   cout << "Size of float : " << sizeof(float) << endl;   cout << "Size of double : " << sizeof(double) << endl;   cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;   return 0;}

本实例使用了 **endl**，这将在每一行后插入一个换行符，<< 运算符用于向屏幕传多个值。我们也使用 **sizeof()** 函数来获取各种数据类型的大小。

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

Size of char : 1Size of int : 4Size of short int : 2Size of long int : 4Size of float : 4Size of double : 8Size of wchar_t : 4

## typedef 声明 ##

您可以使用 **typedef** 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：

typedef type newname;

例如，下面的语句会告诉编译器，feet 是 int 的另一个名称：

typedef int feet;

现在，下面的声明是完全合法的，它创建了一个整型变量 distance：

feet distance;

## 枚举类型 ##

枚举类型声明一个可选的类型名称和一组标识符，用来作为该类型的值。其带有零个或多个标识符可以被用来作为该类型的值。每个枚举数是一个枚举类型的常数。

创建枚举，需要使用关键字 **enum**。枚举类型的一般形式为：

enum enum-name { list of names } var-list;

在这里，enum-name 是枚举类型的名称。名称列表 \{ list of names \} 是用逗号分隔的。

例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 "blue"。

enum color { red, green, blue } c;c = blue;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，**green** 的值为 5。

enum color { red, green=5, blue };

在这里，**blue** 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1。

## C++ 变量作用域 ##

作用域是程序的一个区域，一般来说有三个地方可以声明变量：

*  在函数或一个代码块内部声明的变量，称为局部变量。
 *  在函数参数的定义中声明的变量，称为形式参数。
 *  在所有函数外部声明的变量，称为全局变量。

我们将在后续的章节中学习什么是函数和参数。本章我们先来讲解声明是局部变量和全局变量。

## 局部变量 ##

在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用。下面的实例使用了局部变量：

#include <iostream>using namespace std; int main (){  // 局部变量声明  int a, b;  int c;   // 实际初始化  a = 10;  b = 20;  c = a + b;   cout << c;     return 0; }

## 全局变量 ##

在所有函数外部定义的变量（通常是在程序的头部），称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。

全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的。下面的实例使用了全局变量和局部变量：

#include <iostream>using namespace std; // 全局变量声明int g; int main (){  // 局部变量声明  int a, b;   // 实际初始化  a = 10;  b = 20;  g = a + b;   cout << g;     return 0; }

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。下面是一个实例：

#include <iostream>using namespace std; // 全局变量声明int g = 20; int main (){  // 局部变量声明  int g = 10;   cout << g;     return 0;}

当上面的代码被编译和执行时，它会产生下列结果：

## 初始化局部变量和全局变量 ##

当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：

<table> 
 <tbody> 
  <tr> 
   <th>数据类型</th> 
   <th>初始化默认值</th> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>'\0'</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>pointer</td> 
   <td>NULL</td> 
  </tr> 
 </tbody> 
</table>

正确地初始化变量是一个良好的编程习惯，否则有时候程序可能会产生意想不到的结果。

## C++ 常量 ##

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做**字面量**。

常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。

常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

## 整数常量 ##

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

下面列举几个整数常量的实例：

212         // 合法的215u        // 合法的0xFeeL      // 合法的078         // 非法的：8 不是八进制的数字032UU       // 非法的：不能重复后缀

以下是各种类型的整数常量的实例：

85         // 十进制0213       // 八进制 0x4b       // 十六进制 30         // 整数 30u        // 无符号整数 30l        // 长整数 30ul       // 无符号长整数

## 浮点常量 ##

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含小数点、指数，或同时包含两者。当使用指数形式表示时，必须包含整数部分、小数部分，或同时包含两者。带符号的指数是用 e 或 E 引入的。

下面列举几个浮点常量的实例：

3.14159       // 合法的 314159E-5L    // 合法的 510E          // 非法的：不完整的指数210f          // 非法的：没有小数或指数.e55          // 非法的：缺少整数或分数

## 布尔常量 ##

布尔常量共有两个，它们都是标准的 C++ 关键字：

*  **true** 值代表真。
 *  **false** 值代表假。

我们不应把 true 的值看成 1，把 false 的值看成 0。

## 字符常量 ##

字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L'x'），此时它必须存储在 **wchar\_t** 类型的变量中。否则，它就是一个窄字符常量（例如 'x'），此时它可以存储在 **char** 类型的简单变量中。

字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\\t'），或一个通用的字符（例如 '\\u02C0'）。

在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\\n）或制表符（\\t）等。下表列出了一些这样的转义序列码：

<table> 
 <tbody> 
  <tr> 
   <th>转义序列</th> 
   <th>含义</th> 
  </tr> 
  <tr> 
   <td>\\</td> 
   <td>\ 字符</td> 
  </tr> 
  <tr> 
   <td>\'</td> 
   <td>' 字符</td> 
  </tr> 
  <tr> 
   <td>\"</td> 
   <td>" 字符</td> 
  </tr> 
  <tr> 
   <td>\?</td> 
   <td>? 字符</td> 
  </tr> 
  <tr> 
   <td>\a</td> 
   <td>警报铃声</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>退格键</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>换页符</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>换行符</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>水平制表符</td> 
  </tr> 
  <tr> 
   <td>\v</td> 
   <td>垂直制表符</td> 
  </tr> 
  <tr> 
   <td>\ooo</td> 
   <td>一到三位的八进制数</td> 
  </tr> 
  <tr> 
   <td>\xhh . . .</td> 
   <td>一个或多个数字的十六进制数</td> 
  </tr> 
 </tbody> 
</table>

下面的实例显示了一些转义序列字符：

#include <iostream>using namespace std;int main(){   cout << "Hello\tWorld\n\n";   return 0;}

当上面的代码被编译和执行时，它会产生下列结果：

Hello   World

## 字符串常量 ##

字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

您可以使用空格做分隔符，把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

"hello, dear""hello, \dear""hello, " "d" "ear"

## 定义常量 ##

在 C++ 中，有两种简单的定义常量的方式：

*  使用 **\#define** 预处理器。
 *  使用 **const** 关键字。

## \#define 预处理器 ##

下面是使用 \#define 预处理器定义常量的形式：

#define identifier value

具体请看下面的实例：

#include <iostream>using namespace std;#define LENGTH 10   #define WIDTH  5#define NEWLINE '\n'int main(){   int area;        area = LENGTH * WIDTH;   cout << area;   cout << NEWLINE;   return 0;}

当上面的代码被编译和执行时，它会产生下列结果：

## const 关键字 ##

您可以使用 **const** 前缀声明指定类型的常量，如下所示：

const type variable = value;

具体请看下面的实例：

#include <iostream>using namespace std;int main(){   const int  LENGTH = 10;   const int  WIDTH  = 5;   const char NEWLINE = '\n';   int area;        area = LENGTH * WIDTH;   cout << area;   cout << NEWLINE;   return 0;}

当上面的代码被编译和执行时，它会产生下列结果：

请注意，把常量定义为大写字母形式，是一个很好的编程实践

## C++ 修饰符类型 ##

C++ 允许在 **char、int 和 double** 数据类型前放置修饰符。修饰符用于改变基本类型的含义，所以它更能满足各种情境的需求。

下面列出了数据类型修饰符：

*  signed
 *  unsigned
 *  long
 *  short

修饰符 **signed、unsigned、long 和 short** 可应用于整型，**signed** 和 **unsigned** 可应用于字符型，**long** 可应用于双精度型。

修饰符 **signed** 和 **unsigned** 也可以作为 **long** 或 **short** 修饰符的前缀。例如：**unsigned long int**。

C++ 允许使用速记符号来声明**无符号短整数**或**无符号长整数**。您可以不写 int，只写单词 **unsigned short** 或 **unsigned long**，int 是隐含的。例如，下面的两个语句都声明了无符号整型变量。

unsigned x;unsigned int y;

为了理解 C++ 解释有符号整数和无符号整数修饰符之间的差别，我们来运行一下下面这个短程序：

#include <iostream>using namespace std; /*  * 这个程序演示了有符号整数和无符号整数之间的差别*/int main(){   short int i;           // 有符号短整数   short unsigned int j;  // 无符号短整数   j = 50000;   i = j;   cout << i << " " << j;   return 0;}

当上面的程序运行时，会输出下列结果：

-15536 50000

上述结果中，无符号短整数 50,000 的位模式被解释为有符号短整数 -15,536。

## C++ 中的类型限定符 ##

类型限定符提供了变量的额外信息。

<table> 
 <tbody> 
  <tr> 
   <th>限定符</th> 
   <th>含义</th> 
  </tr> 
  <tr> 
   <td>const</td> 
   <td><strong>const</strong>&nbsp;类型的对象在程序执行期间不能被修改改变。</td> 
  </tr> 
  <tr> 
   <td>volatile</td> 
   <td>修饰符&nbsp;<strong>volatile</strong>&nbsp;告诉编译器，变量的值可能以程序未明确指定的方式被改变。</td> 
  </tr> 
  <tr> 
   <td>restrict</td> 
   <td>由&nbsp;<strong>restrict</strong>&nbsp;修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。<br><br></td> 
  </tr> 
 </tbody> 
</table>

## C++ 存储类 ##

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

*  auto
 *  register
 *  static
 *  extern
 *  mutable

## auto 存储类 ##

**auto** 存储类是所有局部变量默认的存储类。

{   int mount;   auto int month;}

上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。

## register 存储类 ##

**register** 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

{   register int  miles;}

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

## static 存储类 ##

**static** 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

#include <iostream> // 函数声明 void func(void); static int count = 10; /* 全局变量 */ int main(){    while(count--)    {       func();    }    return 0;}// 函数定义void func( void ){    static int i = 5; // 局部静态变量    i++;    std::cout << "变量 i 为 " << i ;    std::cout << " , 变量 count 为 " << count << std::endl;}

当上面的代码被编译和执行时，它会产生下列结果：

变量 i 为 6 , 变量 count 为 9变量 i 为 7 , 变量 count 为 8变量 i 为 8 , 变量 count 为 7变量 i 为 9 , 变量 count 为 6变量 i 为 10 , 变量 count 为 5变量 i 为 11 , 变量 count 为 4变量 i 为 12 , 变量 count 为 3变量 i 为 13 , 变量 count 为 2变量 i 为 14 , 变量 count 为 1变量 i 为 15 , 变量 count 为 0

## extern 存储类 ##

**extern** 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 *extern* 来得到已定义的变量或函数的引用。可以这么理解，*extern* 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件：main.cpp

#include <iostream> int count ;extern void write_extern(); main(){   count = 5;   write_extern();}

第二个文件：support.cpp

#include <iostream> extern int count; void write_extern(void){   std::cout << "Count is " << count << std::endl; }

在这里，第二个文件中的 *extern* 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。现在 ，编译这两个文件，如下所示：

$g++ main.cpp support.cpp -o write

这会产生 **write** 可执行程序，尝试执行 **write**，它会产生下列结果：

$ ./writeCount is 5

## mutable 存储类 ##

**mutable** 说明符仅适用于类的对象，这将在本教程的最后进行讲解。它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

## C++ 运算符 ##

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++ 内置了丰富的运算符，并提供了以下类型的运算符：

*  算术运算符
 *  关系运算符
 *  逻辑运算符
 *  位运算符
 *  赋值运算符
 *  杂项运算符

本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。

## 算术运算符 ##

下表显示了 C++ 支持的所有算术运算符。

假设变量 A 的值为 10，变量 B 的值为 20，则：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>把两个操作数相加</td> 
   <td>A + B 将得到 30</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>从第一个操作数中减去第二个操作数</td> 
   <td>A - B 将得到 -10</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>把两个操作数相乘</td> 
   <td>A * B 将得到 200</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>分子除以分母</td> 
   <td>B / A 将得到 2</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取模运算符，整除后的余数</td> 
   <td>B % A 将得到 0</td> 
  </tr> 
  <tr> 
   <td>++</td> 
   <td>自增运算符，整数值增加 1</td> 
   <td>A++ 将得到 11</td> 
  </tr> 
  <tr> 
   <td>--</td> 
   <td>自减运算符，整数值减少 1</td> 
   <td>A-- 将得到 9</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

请看下面的实例，了解 C++ 中所有可用的算术运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

#include <iostream>using namespace std; main(){   int a = 21;   int b = 10;   int c ;    c = a + b;   cout << "Line 1 - c 的值是 " << c << endl ;    c = a - b;    cout << "Line 2 - c 的值是 " << c << endl ;    c = a * b;    cout << "Line 3 - c 的值是 " << c << endl ;    c = a / b;    cout << "Line 4 - c 的值是 " << c << endl ;    c = a % b;    cout << "Line 5 - c 的值是 " << c << endl ;    c = a++;    cout << "Line 6 - c 的值是 " << c << endl ;    c = a--;    cout << "Line 7 - c 的值是 " << c << endl ;return 0; }

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - c 的值是 31Line 2 - c 的值是 11Line 3 - c 的值是 210Line 4 - c 的值是 2Line 5 - c 的值是 1Line 6 - c 的值是 21Line 7 - c 的值是 22

## 关系运算符 ##

下表显示了 C++ 支持的所有关系运算符。

假设变量 A 的值为 10，变量 B 的值为 20，则：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>检查两个操作数的值是否相等，如果相等则条件为真。</td> 
   <td>(A == B) 不为真。</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>检查两个操作数的值是否相等，如果不相等则条件为真。</td> 
   <td>(A != B) 为真。</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>检查左操作数的值是否大于右操作数的值，如果是则条件为真。</td> 
   <td>(A &gt; B) 不为真。</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>检查左操作数的值是否小于右操作数的值，如果是则条件为真。</td> 
   <td>(A &lt; B) 为真。</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。</td> 
   <td>(A &gt;= B) 不为真。</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。</td> 
   <td>(A &lt;= B) 为真。</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

请看下面的实例，了解 C++ 中所有可用的关系运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

#include <iostream>using namespace std;main(){   int a = 21;   int b = 10;   int c ;   if( a == b )   {      cout << "Line 1 - a 等于 b" << endl ;     }else{    cout << "Line 1 - a 不等于 b" << endl ;    }    if ( a < b ) {        cout << "Line 2 - a 小于 b" << endl ;    }else{        cout << "Line 2 - a 不小于 b" << endl ;    }    if ( a > b ){      cout << "Line 3 - a 大于 b" << endl ;    }else{        cout << "Line 3 - a 不大于 b" << endl ;    }    /* 改变 a 和 b 的值 */    a = 5;    b = 20;    if ( a <= b ){    cout << "Line 4 - a 小于或等于 b" << endl ;    }    if ( b >= a ){      cout << "Line 5 - b 大于或等于 b" << endl ;    }    return 0; }

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - a 不等于 bLine 2 - a 不小于 bLine 3 - a 大于 bLine 4 - a 小于或等于 bLine 5 - b 大于或等于 b

## 逻辑运算符 ##

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

假设变量 A 的值为 1，变量 B 的值为 0，则：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>称为逻辑与运算符。如果两个操作数都非零，则条件为真。</td> 
   <td>(A &amp;&amp; B) 为假。</td> 
  </tr> 
  <tr> 
   <td>||</td> 
   <td>称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。</td> 
   <td>(A || B) 为真。</td> 
  </tr> 
  <tr> 
   <td>!</td> 
   <td>称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。</td> 
   <td>!(A &amp;&amp; B) 为真。</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

请看下面的实例，了解 C++ 中所有可用的逻辑运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

#include <iostream>using namespace std;main(){   int a = 5;   int b = 20;   int c ;   if ( a && b )   {      cout << "Line 1 - 条件为真"<< endl ;    }    if ( a || b )    {        cout << "Line 2 - 条件为真"<< endl ;    }    /* 改变 a 和 b 的值 */    a = 0;    b = 10;    if ( a && b )    {        cout << "Line 3 - 条件为真"<< endl ;    }else{        cout << "Line 4 - 条件不为真"<< endl ;    }    if ( !(a && b) ){    cout << "Line 5 - 条件为真"<< endl ;    }    return 0;}

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - 条件为真Line 2 - 条件为真Line 3 - 条件不为真Line 4 - 条件为真

## 位运算符 ##

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

假设如果 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> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。</td> 
   <td>(A &amp; B) 将得到 12，即为 0000 1100</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。</td> 
   <td>(A | B) 将得到 61，即为 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。</td> 
   <td>(A ^ B) 将得到 49，即为 0011 0001</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>二进制补码运算符是一元运算符，具有"翻转"位效果。</td> 
   <td>(~A ) 将得到 -61，即为 1100 0011，2 的补码形式，带符号的二进制数。</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>二进制左移运算符。左操作数的值向左移动右操作数指定的位数。</td> 
   <td>A &lt;&lt; 2 将得到 240，即为 1111 0000</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>二进制右移运算符。左操作数的值向右移动右操作数指定的位数。</td> 
   <td>A &gt;&gt; 2 将得到 15，即为 0000 1111</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

请看下面的实例，了解 C++ 中所有可用的位运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

#include <iostream>using namespace std;main(){   unsigned int a = 60;     // 60 = 0011 1100     unsigned int b = 13;    // 13 = 0000 1101   int c = 0;              c = a & b;             // 12 = 0000 1100   cout << "Line 1 - c 的值是 " << c << endl ;    c = a | b;             // 61 = 0011 1101    cout << "Line 2 - c 的值是 " << c << endl ;    c = a ^ b;             // 49 = 0011 0001    cout << "Line 3 - c 的值是 " << c << endl ;    c = ~a;                // -61 = 1100 0011    cout << "Line 4 - c 的值是 " << c << endl ;    c = a << 2;            // 240 = 1111 0000    cout << "Line 5 - c 的值是 " << c << endl ;    c = a >> 2;            // 15 = 0000 1111    cout << "Line 6 - c 的值是 " << c << endl ;    return 0; }

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - c 的值是 12Line 2 - c 的值是 61Line 3 - c 的值是 49Line 4 - c 的值是 -61Line 5 - c 的值是 240Line 6 - c 的值是 15

## 赋值运算符 ##

下表列出了 C++ 支持的赋值运算符：

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

### 实例 ###

请看下面的实例，了解 C++ 中所有可用的赋值运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

#include <iostream>using namespace std;main(){   int a = 21;   int c ;   c =  a;   cout << "Line 1 - =  运算符实例，c 的值 = : " <<c<< endl ;    c +=  a;    cout << "Line 2 - += 运算符实例，c 的值 = : " <<c<< endl ;    c -=  a;    cout << "Line 3 - -= 运算符实例，c 的值 = : " <<c<< endl ;    c *=  a;    cout << "Line 4 - *= 运算符实例，c 的值 = : " <<c<< endl ;    c /=  a;    cout << "Line 5 - /= 运算符实例，c 的值 = : " <<c<< endl ;    c  = 200;    c %=  a;    cout << "Line 6 - %= 运算符实例，c 的值 = : " <<c<< endl ;    c <<=  2;    cout << "Line 7 - <<= 运算符实例，c 的值 = : " <<c<< endl ;    c >>=  2;    cout << "Line 8 - >>= 运算符实例，c 的值 = : " <<c<< endl ;    c &=  2;    cout << "Line 9 - &= 运算符实例，c 的值 = : " <<c<< endl ;    c ^=  2;    cout << "Line 10 - ^= 运算符实例，c 的值 = : " <<c<< endl ;    c |=  2;    cout << "Line 11 - |= 运算符实例，c 的值 = : " <<c<< endl ;    return 0; }

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - =  运算符实例，c 的值 = 21Line 2 - += 运算符实例，c 的值 = 42Line 3 - -= 运算符实例，c 的值 = 21Line 4 - *= 运算符实例，c 的值 = 441Line 5 - /= 运算符实例，c 的值 = 21Line 6 - %= 运算符实例，c 的值 = 11Line 7 - <<= 运算符实例，c 的值 = 44 Line 8 - >>= 运算符实例，c 的值 = 11Line 9 - &= 运算符实例，c 的值 = 2Line 10 - ^= 运算符实例，c 的值 = 0Line 11 - |= 运算符实例，c 的值 = 2

## 杂项运算符 ##

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

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>sizeof</td> 
   <td>sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。</td> 
  </tr> 
  <tr> 
   <td>Condition ? X : Y</td> 
   <td>条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。</td> 
  </tr> 
  <tr> 
   <td>,</td> 
   <td>逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。</td> 
  </tr> 
  <tr> 
   <td>.（点）和 -&gt;（箭头）</td> 
   <td>成员运算符用于引用类、结构和共用体的成员。</td> 
  </tr> 
  <tr> 
   <td>Cast</td> 
   <td>强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>指针运算符 &amp;&nbsp;返回变量的地址。例如 &amp;a; 将给出变量的实际地址。</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>指针运算符 *&nbsp;指向一个变量。例如，*var; 将指向变量 var。</td> 
  </tr> 
 </tbody> 
</table>

## C++ 中的运算符优先级 ##

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

例如 x = 7 + 3 \* 2，在这里，x 被赋值为 13，而不是 20，因为运算符 \* 具有比 + 更高的优先级，所以首先计算乘法 3\*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

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

### 实例 ###

请看下面的实例，了解 C++ 中运算符的优先级。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

对比有括号和没有括号时的区别，这将产生不同的结果。因为 ()、 /、 \* 和 + 有不同的优先级，高优先级的操作符将优先计算。

#include <iostream>using namespace std; main(){   int a = 20;   int b = 10;   int c = 15;   int d = 5;   int e;    e = (a + b) * c / d;      // ( 30 * 15 ) / 5   cout << "(a + b) * c / d 的值是 " << e << endl ;   e = ((a + b) * c) / d;    // (30 * 15 ) / 5   cout << "((a + b) * c) / d 的值是 " << e << endl ;   e = (a + b) * (c / d);   // (30) * (15/5)   cout << "(a + b) * (c / d) 的值是 " << e << endl ;   e = a + (b * c) / d;     //  20 + (150/5)   cout << "a + (b * c) / d 的值是 " << e << endl ;     return 0;}

当上面的代码被编译和执行时，它会产生下列结果：

(a + b) * c / d 的值是 90((a + b) * c) / d 的值是 90(a + b) * (c / d) 的值是 90a + (b * c) / d 的值是 50

--------------------

### **推荐阅读** ###

• [吴师兄实名吐槽 LeetCode 上的一道题目。。。][LeetCode]• [面试字节跳动时，我竟然遇到了原题……][Link 1]• [计算机专业的学生怎样练习编程才能把编程学精通？][Link 2]• [为什么 MySQL 使用 B+ 树][MySQL _ B_]• [一道简简单单的字节跳动算法面试题][Link 3]

--------------------

欢迎关注我的公众号“**五分钟学算法**”，如果喜欢，麻烦点一下“**在看**”~

![format_png 2][]

[format_png]: /images/20221123/1f32ed0e76c449c8948c734752820fa8.png
[format_png 1]: /images/20221123/ae6426c1f2834ac7857efb3c949cefc7.png
[LeetCode]: http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg%3D%3D&chksm=fa0e75efcd79fcf9c65ebb5070122b9705e18cb1c46b06c5eb3e299520ed4a25e327bc07bb4b&idx=2&mid=2247490158&scene=21&sn=12e587a361f0df072d2dc164c219a61e#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg%3D%3D&chksm=fa0e75aecd79fcb8b5f932c7ba5ed7a9e34a6c99f20bc129cef33774167d668e8745755d02ad&idx=1&mid=2247490095&scene=21&sn=baa0379b1ca62db17327a2cb825a1b24#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg%3D%3D&chksm=fa0d87aacd7a0ebc3ada34a076d1fa3943ee24097966257132b1042b7a3e4debedc78f38c8cf&idx=1&mid=2247493675&scene=21&sn=6b501ef2032ab911f0a3519eb7397017#wechat_redirect
[MySQL _ B_]: http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg%3D%3D&chksm=fa0e759ccd79fc8a73c77eacfd7c8b1391b08864e2e13fdf5a6e41e218a499d5a87ee12e4e6a&idx=2&mid=2247490077&scene=21&sn=56c52b385c98c7f0ad33c2621da101eb#wechat_redirect
[Link 3]: http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg%3D%3D&chksm=fa0e767dcd79ff6b2733dd8905f188afb19eb400d5e644f5b5127f909ee7c3583786031f9c20&idx=2&mid=2247490044&scene=21&sn=bb3610dfedbb2e0c017c3ff3d5e4684b#wechat_redirect
[format_png 2]: /images/20221123/e4f4a42469aa41fcaad1721a9e5011f4.png