C++ 快速指南

---

C++ 概述

C++ 是一种静态类型、编译型、通用、区分大小写、自由格式的编程语言，支持过程式、面向对象和泛型编程。

C++ 被视为中级语言，因为它结合了高级语言和低级语言的功能。

C++ 由 Bjarne Stroustrup 于 1979 年在新泽西州默里山的贝尔实验室开发，作为 C 语言的增强，最初命名为 C with Classes，但后来于 1983 年更名为 C++。

C++ 是 C 的超集，几乎任何合法的 C 程序都是合法的 C++ 程序。

注意- 当在编译时而不是运行时执行类型检查时，编程语言被称为使用静态类型。

面向对象编程

C++ 完全支持面向对象编程，包括面向对象开发的四大支柱 -

• 封装
• 数据隐藏
• 遗产
• 多态性

标准库

标准 C++ 由三个重要部分组成 -

• 核心语言提供了所有构建块，包括变量、数据类型和文字等。

• C++ 标准库提供了一组丰富的函数来操作文件、字符串等。

• 标准模板库（STL）提供了一组丰富的操作数据结构的方法等。

ANSI 标准

ANSI 标准是为了确保 C++ 是可移植的；您为 Microsoft 编译器编写的代码可以使用 Mac、UNIX、Windows 机器或 Alpha 上的编译器进行编译，不会出现错误。

ANSI 标准已经稳定了一段时间了，所有主要的 C++ 编译器制造商都支持 ANSI 标准。

学习 C++

学习 C++ 时最重要的是关注概念。

学习编程语言的目的是成为一名更好的程序员；也就是说，在设计和实施新系统以及维护旧系统方面变得更加有效。

C++ 支持多种编程风格。您可以用 Fortran、C、Smalltalk 等任何语言的风格进行编写。每种风格都可以有效地实现其目标，同时保持运行时间和空间效率。

C++的使用

几乎每个应用领域都有数十万程序员使用 C++。

C++ 被广泛用于编写设备驱动程序和其他在实时限制下依赖于直接操作硬件的软件。

C++ 广泛用于教学和研究，因为它足够干净，足以成功教授基本概念。

任何使用过 Apple Macintosh 或运行 Windows 的 PC 的人都间接使用过 C++，因为这些系统的主要用户界面是用 C++ 编写的。

C++环境设置

本地环境设置

如果您仍然愿意为 C++ 设置环境，则您的计算机上需要安装以下两个软件。

文本编辑器

这将用于输入您的程序。少数编辑器的示例包括 Windows 记事本、操作系统编辑命令、Brief、Epsilon、EMACS 和 vim 或 vi。

文本编辑器的名称和版本可能因不同操作系统而异。例如，记事本将在 Windows 上使用，vim 或 vi 可以在 Windows 以及 Linux 或 UNIX 上使用。

您使用编辑器创建的文件称为源文件，对于 C++，它们通常以扩展名 .cpp、.cp 或 .c 命名。

应该有一个文本编辑器来开始您的 C++ 编程。

C++编译器

这是一个实际的 C++ 编译器，它将用于将源代码编译为最终的可执行程序。

大多数 C++ 编译器并不关心您为源代码提供的扩展名，但如果您不另外指定，许多编译器将默认使用 .cpp。

最常用且免费的编译器是 GNU C/C++ 编译器，否则，如果您有相应的操作系统，则可以使用 HP 或 Solaris 的编译器。

安装 GNU C/C++ 编译器

UNIX/Linux 安装

如果您使用的是Linux 或 UNIX，则通过从命令行输入以下命令来检查您的系统上是否安装了 GCC -

$ g++ -v

如果您已经安装了 GCC，那么它应该打印一条消息，如下所示 -

Using built-in specs.
Target: i386-redhat-linux
Configured with: ../configure --prefix=/usr .......
Thread model: posix
gcc version 4.1.2 20080704 (Red Hat 4.1.2-46)

如果未安装 GCC，则您必须使用https://gcc.gnu.org/install/上提供的详细说明自行安装它

Mac OS X 安装

如果您使用Mac OS X，获取GCC的最简单方法是从Apple网站下载Xcode开发环境并按照简单的安装说明进行操作。

Xcode 目前可在developer.apple.com/technologies/tools/上获取。

Windows安装

要在 Windows 上安装 GCC，您需要安装 MinGW。要安装 MinGW，请访问 MinGW 主页www.mingw.org，然后点击链接进入 MinGW 下载页面。下载最新版本的 MinGW 安装程序，其名称应为 MinGW-<version>.exe。

安装 MinGW 时，您至少必须安装 gcc-core、gcc-g++、binutils 和 MinGW 运行时，但您可能希望安装更多。

将 MinGW 安装的 bin 子目录添加到PATH环境变量中，以便您可以在命令行上通过简单名称指定这些工具。

安装完成后，您将能够从 Windows 命令行运行 gcc、g++、ar、ranlib、dlltool 和其他几个 GNU 工具。

C++ 基本语法

当我们考虑 C++ 程序时，它可以定义为通过调用彼此的方法进行通信的对象的集合。现在让我们简单地了解一下类、对象、方法和即时变量的含义。

• 对象- 对象具有状态和Behave。示例：狗有状态 - 颜色、名称、品种以及Behave - 摇摆、吠叫、进食。对象是类的实例。

• 类- 类可以定义为模板/蓝图，描述其类型的对象支持的Behave/状态。

• 方法- 方法基本上是一种Behave。一个类可以包含许多方法。在方法中编写逻辑、操作数据并执行所有操作。

• 实例变量- 每个对象都有其唯一的实例变量集。对象的状态是由分配给这些实例变量的值创建的。

C++程序结构

让我们看一个简单的代码，它将打印Hello World一词。

#include <iostream>
using namespace std;

// main() is where program execution begins.
int main() {
   cout << "Hello World"; // prints Hello World
   return 0;
}

让我们看看上面程序的各个部分 -

• C++ 语言定义了多个标头，其中包含对程序必需或有用的信息。对于这个程序，需要头<iostream> 。

• 使用命名空间 std 的行；告诉编译器使用 std 命名空间。命名空间是 C++ 中相对较新的补充。

• 下一行' // main() 是程序执行开始的地方。' 是 C++ 中可用的单行注释。单行注释以 // 开始，到行尾停止。

• int main()行是程序开始执行的主函数。

• 下一行cout << "Hello World"; 导致屏幕上显示消息“Hello World”。

• 下一行返回0；终止 main() 函数并使其返回值 0 给调用进程。

编译并执行C++程序

我们来看看如何保存文件、编译和运行程序。请按照以下步骤操作 -

• 打开文本编辑器并添加上面的代码。

• 将文件另存为：hello.cpp

• 打开命令提示符并转到保存文件的目录。

• 输入“g++ hello.cpp”并按 Enter 编译代码。如果代码中没有错误，命令提示符将带您进入下一行并生成 .out 可执行文件。

• 现在，输入“a.out”来运行您的程序。

• 您将能够看到窗口上印有“Hello World”。

$ g++ hello.cpp
$ ./a.out
Hello World

确保 g++ 在您的路径中，并且您正在包含文件 hello.cpp 的目录中运行它。

您可以使用 makefile 编译 C/C++ 程序。有关更多详细信息，您可以查看我们的“Makefile 教程”。

C++ 中的分号和块

在 C++ 中，分号是语句终止符。也就是说，每个单独的语句必须以分号结束。它表示一个逻辑实体的结束。

例如，以下是三个不同的陈述 -

x = y;
y = y + 1;
add(x, y);

块是一组逻辑连接的语句，由左大括号和右大括号包围。例如 -

{
   cout << "Hello World"; // prints Hello World
   return 0;
}

C++ 不将行尾识别为终止符。因此，将语句放在一行中的哪个位置并不重要。例如 -

x = y;
y = y + 1;
add(x, y);

是相同的

x = y; y = y + 1; add(x, y);

C++ 标识符

C++ 标识符是用于标识变量、函数、类、模块或任何其他用户定义项的名称。标识符以字母 A 到 Z 或 a 到 z 或下划线 (_) 开头，后跟零个或多个字母、下划线和数字（0 到 9）。

C++ 不允许在标识符中使用标点符号，例如 @、$ 和 %。C++ 是一种区分大小写的编程语言。因此，Manpower和manpower在 C++ 中是两个不同的标识符。

以下是可接受的标识符的一些示例 -

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

C++ 关键字

下面的列表显示了 C++ 中的保留字。这些保留字不得用作常量、变量或任何其他标识符名称。

三字母组

一些字符有另一种表示形式，称为三字母序列。三字符组是表示单个字符的三字符序列，并且该序列始终以两个问号开头。

三字母组会在出现的任何地方展开，包括在字符串文字和字符文字中、在注释中以及在预处理器指令中。

以下是最常用的三字母序列 -

所有编译器都不支持三字母组，并且由于其令人困惑的性质，不建议使用它们。

C++ 中的空白

仅包含空格（可能带有注释）的行称为空行，C++ 编译器完全忽略它。

空白是 C++ 中用来描述空白、制表符、换行符和注释的术语。空格将语句的一部分与另一部分分隔开，并使编译器能够识别语句中一个元素（例如 int）的结束位置和下一个元素的开始位置。

声明1

int age;

在上面的语句中，int和age之间必须至少有一个空白字符（通常是一个空格），以便编译器能够区分它们。

声明2

fruit = apples + oranges;   // Get the total fruit

在上面的语句 2 中，水果和 = 之间或 = 和苹果之间不需要空格字符，但如果您希望出于可读性目的，可以自由地包含一些空格字符。

C++ 中的注释

程序注释是可以包含在 C++ 代码中的解释性语句。这些注释可以帮助任何阅读源代码的人。所有编程语言都允许某种形式的注释。

C++ 支持单行和多行注释。C++ 编译器将忽略任何注释中可用的所有字符。

C++ 注释以 /* 开始，以 */ 结束。例如 -

/* This is a comment */

/* C++ comments can also
   * span multiple lines
*/

注释也可以以 // 开头，一直延伸到行尾。例如 -

#include <iostream>
using namespace std;

main() {
   cout << "Hello World"; // prints Hello World
   
   return 0;
}

当上面的代码被编译时，它将忽略//打印Hello World，最终的可执行文件将产生以下结果 -

Hello World

在 /* 和 */ 注释中，// 字符没有特殊含义。在 // 注释中，/* 和 */ 没有特殊含义。因此，您可以将一种注释“嵌套”在另一种注释中。例如 -

/* Comment out printing of Hello World:

cout << "Hello World"; // prints Hello World

*/

C++ 数据类型

在用任何语言编写程序时，都需要使用各种变量来存储各种信息。变量只不过是用于存储值的保留内存位置。这意味着当您创建变量时，您会在内存中保留一些空间。

您可能喜欢存储各种数据类型的信息，如字符、宽字符、整数、浮点、双浮点、布尔值等。操作系统根据变量的数据类型分配内存并决定可以存储的内容保留内存。

原始内置类型

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

可以使用这些类型修饰符中的一个或多个来修改几种基本类型 -

• 签
• 未签名
• 短的
• 长的

下表显示了变量类型、在内存中存储该值需要多少内存以及该类型变量可以存储的最大值和最小值是多少。

变量的大小可能与上表中显示的不同，具体取决于您使用的编译器和计算机。

以下是示例，它将在您的计算机上生成各种数据类型的正确大小。

#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 : 1
Size of int : 4
Size of short int : 2
Size of long int : 4
Size of float : 4
Size of double : 8
Size of wchar_t : 4

typedef 声明

您可以使用typedef为现有类型创建新名称。以下是使用 typedef 定义新类型的简单语法 -

typedef type newname; 

例如，以下内容告诉编译器 foot 是 int 的另一个名称 -

typedef int feet;

现在，以下声明是完全合法的，并创建一个名为距离的整数变量 -

feet distance;

枚举类型

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

创建枚举需要使用关键字enum。枚举类型的一般形式是 -

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

这里，enum-name 是枚举的类型名称。名称列表以逗号分隔。

例如，以下代码定义了称为颜色的颜色枚举和颜色类型的变量 c。最后，c 被赋予值“blue”。

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

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，依此类推。但是您可以通过添加初始值设定项来给出名称和特定值。例如，在以下枚举中，绿色的值为 5。

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

此处，蓝色的值为 6，因为每个名称都会比其前面的名称大 1。

C++ 变量类型

变量为我们提供了程序可以操作的命名存储。C++中的每个变量都有一个特定的类型，它决定了变量内存的大小和布局；该内存中可以存储的值的范围；以及可以应用于变量的操作集。

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写和小写字母是不同的，因为 C++ 区分大小写 -

如上一章所述，C++ 中有以下基本类型的变量 -

C++ 还允许定义各种其他类型的变量，我们将在后续章节中介绍这些变量，例如枚举、指针、数组、引用、数据结构和类。

以下部分将介绍如何定义、声明和使用各种类型的变量。

C++ 中的变量定义

变量定义告诉编译器在何处以及为变量创建多少存储空间。变量定义指定一种数据类型，并包含该类型的一个或多个变量的列表，如下所示 -

type variable_list;

这里，type必须是有效的 C++ 数据类型，包括 char、w_char、int、float、double、bool 或任何用户定义的对象等，variable_list可以由一个或多个以逗号分隔的标识符名称组成。这里显示了一些有效的声明 -

int    i, j, k;
char   c, ch;
float  f, salary;
double d;

该行int i, j, k; 两者都声明并定义了变量 i、j 和 k；它指示编译器创建名为 i、j 和 k 的 int 类型变量。

变量可以在其声明中初始化（分配初始值）。初始化器由一个等号后跟一个常量表达式组成，如下所示 -

type variable_name = value;

一些例子是 -

extern int d = 3, f = 5;    // declaration of d and f. 
int d = 3, f = 5;           // definition and initializing d and f. 
byte z = 22;                // definition and initializes z. 
char x = 'x';               // the variable x has the value 'x'.

对于没有初始化器的定义：具有静态存储持续时间的变量隐式初始化为 NULL（所有字节的值为 0）；所有其他变量的初始值未定义。

C++ 中的变量声明

变量声明向编译器保证存在一个具有给定类型和名称的变量，以便编译器继续进行进一步编译，而无需有关该变量的完整详细信息。变量声明仅在编译时才有意义，编译器在程序链接时需要实际的变量定义。

当您使用多个文件并且在链接程序时可用的文件之一中定义变量时，变量声明非常有用。您将在任何地方使用extern关键字声明变量。虽然您可以在 C++ 程序中多次声明一个变量，但它只能在一个文件、函数或代码块中定义一次。

例子

尝试以下示例，其中变量已在顶部声明，但已在主函数内定义 -

#include <iostream>
using namespace std;

// Variable declaration:
extern int a, b;
extern int c;
extern float f;
  
int main () {
   // Variable definition:
   int a, b;
   int c;
   float f;
 
   // actual initialization
   a = 10;
   b = 20;
   c = a + b;
 
   cout << c << endl ;

   f = 70.0/3.0;
   cout << f << endl ;
 
   return 0;
}

当上面的代码被编译并执行时，它会产生以下结果 -

30
23.3333

同样的概念适用于函数声明，您在声明时提供函数名称，而其实际定义可以在其他任何地方给出。例如 -

// function declaration
int func();
int main() {
   // function call
   int i = func();
}

// function definition
int func() {
   return 0;
}

左值和右值

C++ 中有两种表达式 -

• 左值- 引用内存位置的表达式称为“左值”表达式。左值可以显示为赋值的左侧或右侧。

• 右值- 术语右值是指存储在内存中某个地址的数据值。右值是一个不能赋值的表达式，这意味着右值可以出现在赋值的右侧，但不能出现在左侧。

变量是左值，因此可能出现在赋值的左侧。数字文字是右值，因此不能被赋值，也不能出现在左侧。以下是有效的声明 -

int g = 20;

但以下不是有效的语句，会生成编译时错误 -

10 = 20;

C++ 中的变量作用域

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

• 在称为局部变量的函数或块内，

• 在函数定义中的参数称为形式参数。

• 在所有函数之外称为全局变量。

我们将在后续章节中学习什么是函数及其参数。下面我们来解释一下什么是局部变量和全局变量。

局部变量

在函数或块内声明的变量是局部变量。它们只能由该函数或代码块内的语句使用。局部变量对其自身之外的函数来说是未知的。以下是使用局部变量的示例 -

#include <iostream>
using namespace std;
 
int main () {
   // Local variable declaration:
   int a, b;
   int c;
 
   // actual initialization
   a = 10;
   b = 20;
   c = a + b;
 
   cout << c;
 
   return 0;
}

全局变量

全局变量在所有函数之外定义，通常在程序顶部。全局变量将在程序的整个生命周期中保持其值。

全局变量可以被任何函数访问。也就是说，全局变量在声明后即可在整个程序中使用。以下是使用全局变量和局部变量的示例 -

#include <iostream>
using namespace std;
 
// Global variable declaration:
int g;
 
int main () {
   // Local variable declaration:
   int a, b;
 
   // actual initialization
   a = 10;
   b = 20;
   g = a + b;
  
   cout << g;
 
   return 0;
}

程序中的局部变量和全局变量可以具有相同的名称，但函数内的局部变量的值将优先。例如 -

#include <iostream>
using namespace std;
 
// Global variable declaration:
int g = 20;
 
int main () {
   // Local variable declaration:
   int g = 10;
 
   cout << g;
 
   return 0;
}

当上面的代码被编译并执行时，它会产生以下结果 -

10

初始化局部和全局变量

局部变量定义后，系统不会对其进行初始化，必须自行初始化。当您按如下方式定义全局变量时，系统会自动初始化它们 -

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

C++ 常量/文字

常量是指程序不能更改的固定值，它们称为文字。

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

同样，常量的处理方式与常规变量一样，只是它们的值在定义后不能修改。

整数文字

整数文字可以是十进制、八进制或十六进制常量。前缀指定基数或基数：0x 或 0X 表示十六进制，0 表示八进制，没有任何内容表示十进制。

整数文字还可以具有 U 和 L 的组合后缀，分别表示无符号和长整型。后缀可以是大写或小写，并且可以是任何顺序。

以下是整数文字的一些示例 -

212         // Legal
215u        // Legal
0xFeeL      // Legal
078         // Illegal: 8 is not an octal digit
032UU       // Illegal: cannot repeat a suffix

以下是各种类型整数文字的其他示例 -

85         // decimal
0213       // octal
0x4b       // hexadecimal
30         // int
30u        // unsigned int
30l        // long
30ul       // unsigned long

浮点文字

浮点文字具有整数部分、小数点、小数部分和指数部分。您可以用十进制形式或指数形式表示浮点文字。

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

以下是浮点文字的一些示例 -

3.14159       // Legal
314159E-5L    // Legal
510E          // Illegal: incomplete exponent
210f          // Illegal: no decimal or exponent
.e55          // Illegal: missing integer or fraction

布尔文字

有两个布尔文字，它们是标准 C++ 关键字的一部分 -

• true值代表 true。

• false值代表 false。

您不应将 true 值视为等于 1，将 false 值视为等于 0。

字符文字

字符文字用单引号括起来。如果文字以 L 开头（仅限大写），则它是宽字符文字（例如，L'x'）并且应存储在wchar_t类型的变量中。否则，它是一个窄字符文字（例如，'x'），并且可以存储在char类型的简单变量中。

字符文字可以是普通字符（例如“x”）、转义序列（例如“\t”）或通用字符（例如“\u02C0”）。

C++ 中有一些字符，当它们前面有反斜杠时，它们将具有特殊含义，它们用于表示换行符 (\n) 或制表符 (\t)。在这里，您有一些此类转义序列代码的列表 -

以下是显示一些转义序列字符的示例 -

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

当上面的代码被编译并执行时，它会产生以下结果 -

50

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

当上面的代码被编译并执行时，它会产生以下结果 -

50

请注意，以大写字母定义常量是一种良好的编程习惯。

C++ 修饰符类型

C++ 允许char、int和double数据类型在其前面有修饰符。修饰符用于改变基本类型的含义，使其更准确地适应各种情况的需要。

此处列出了数据类型修饰符 -

• 签
• 未签名
• 长的
• 短的

修饰符signed、unsigned、long和short可以应用于整数基类型。另外，signed和unsigned可以应用于char，long可以应用于double。

有符号和无符号修饰符也可以用作长修饰符或短修饰符的前缀。例如，unsigned long int。

C++ 允许使用速记符号来声明无符号、短整型或长整型。您可以简单地使用单词unsigned、short或long，而不使用int。它自动暗示了int。例如，以下两个语句都声明无符号整型变量。

unsigned x;
unsigned int y;

要了解 C++ 解释有符号和无符号整数修饰符的方式之间的差异，您应该运行以下短程序 -

#include <iostream>
using namespace std;
 
/* This program shows the difference between
   * signed and unsigned integers.
*/
int main() {
   short int i;           // a signed short integer
   short unsigned int j;  // an unsigned short integer

   j = 50000;

   i = j;
   cout << i << " " << j;

   return 0;
}

运行该程序时，输出如下 -

-15536 50000

上面的结果是因为将 50,000 表示为短无符号整数的位模式被短整型解释为 -15,536。

C++ 中的类型限定符

类型限定符提供有关它们前面的变量的附加信息。

C++ 中的存储类

存储类定义 C++ 程序中变量和/或函数的范围（可见性）和生命周期。这些说明符位于它们所修改的类型之前。有以下存储类，可以在C++程序中使用

• 汽车
• 登记
• 静止的
• 外部的
• 可变的

自动存储类

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

{
   int mount;
   auto int month;
}

上面的例子定义了两个具有相同存储类别的变量，auto只能在函数内使用，即局部变量。

寄存器存储类

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

{
   register int  miles;
}

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

静态存储类

静态存储类指示编译器在程序的生命周期内保持局部变量的存在，而不是在每次进入和离开作用域时创建和销毁它。因此，将局部变量设为静态可以让它们在函数调用之间保持其值。

static 修饰符也可以应用于全局变量。完成此操作后，会导致该变量的范围仅限于声明它的文件。

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

#include <iostream>
 
// Function declaration
void func(void);
 
static int count = 10; /* Global variable */
 
main() {
   while(count--) {
      func();
   }
   
   return 0;
}

// Function definition
void func( void ) {
   static int i = 5; // local static variable
   i++;
   std::cout << "i is " << i ;
   std::cout << " and count is " << count << std::endl;
}

当上面的代码被编译并执行时，它会产生以下结果 -

i is 6 and count is 9
i is 7 and count is 8
i is 8 and count is 7
i is 9 and count is 6
i is 10 and count is 5
i is 11 and count is 4
i is 12 and count is 3
i is 13 and count is 2
i is 14 and count is 1
i is 15 and count is 0

外部存储类

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关键字用于在另一个文件中声明计数。现在编译这两个文件如下 -

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

这将生成write可执行程序，尝试执行write并检查结果，如下所示 -

$./write
5

可变存储类

可变说明符仅适用于类对象，本教程稍后将对此进行讨论。它允许对象的成员覆盖 const 成员函数。也就是说，可变成员可以由 const 成员函数修改。

C++ 中的运算符

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

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

本章将一一考察算术、关系、逻辑、位、赋值等运算符。

算术运算符

C++ 语言支持以下算术运算符 -

假设变量 A 为 10，变量 B 为 20，则 -

显示示例

关系运算符

C++语言支持的关系运算符有以下几种

假设变量 A 为 10，变量 B 为 20，则 -

显示示例

逻辑运算符

C++语言支持以下逻辑运算符。

假设变量 A 为 1，变量 B 为 0，则 -

显示示例

按位运算符

位运算符作用于位并执行逐位运算。&、| 和 ^ 的真值表如下 -

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

显示示例

赋值运算符

C++ 语言支持以下赋值运算符 -

显示示例

杂项运算符

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

C++ 中的运算符优先级

运算符优先级决定表达式中术语的分组。这会影响表达式的计算方式。某些运算符的优先级高于其他运算符；例如，乘法运算符的优先级高于加法运算符 -

例如x = 7 + 3 * 2；此处，x 被分配为 13，而不是 20，因为运算符 * 的优先级高于 +，因此它首先乘以 3*2，然后添加到 7。

在这里，优先级最高的运算符出现在表的顶部，优先级最低的运算符出现在底部。在表达式中，将首先计算优先级较高的运算符。

显示示例

C++ 循环类型

可能存在一种情况，当您需要多次执行一段代码时。一般来说，语句是按顺序执行的：首先执行函数中的第一个语句，然后执行第二个语句，依此类推。

编程语言提供了各种控制结构，允许更复杂的执行路径。

循环语句允许我们多次执行一条语句或一组语句，以下是大多数编程语言中循环语句的一般形式 -

C++ 编程语言提供以下类型的循环来处理循环需求。