当我们编写程序时，通常需要存储一些信息，这些信息有的被临时存储在内存中，有的则长期保存在硬盘等存储设备中。在程序运行期间，变量主要被存储在内存^[1]中，本章我们将主要讨论存储在内存中的数据（即变量），的相关内容。把数据存储在计算机中，程序必须明白 3 个必要的特征：

• 数据将被存储在哪里
• 要以何种类型存储数据
• 要存储什么值（内容）

通过之前的“程序代码”范例，大家应该可以看到我们使用的声明中，类型描述了信息的类型并且通过特殊的字母组合（即单词）描述了其值的变量名称。例如程序代码2-2中使用了

1
2

int age;
age = 18;

这些语句告诉程序，他正在存储 int 型整数，并使用 age 来表示 该整数的值（这里是 18 ）。实际上这里没有给出注释，但大家都可以明白 age 代表年龄并且年龄是 18，这便是本文下一小节（3.1.1 变量名）即将提到的一个优秀的变量名的重要性。

程序会找到一块能够存储 int 型整数的内容，将所占用的内存（存储）单元标记为 age，并将 18 复制到该内存单元中。这些语句执行后，我们任何人不会知道这个值被存储在内存的什么位置，但我们的程序替我们记录了存储的信息。我们可以使用 & 操作符进行检索 age 在内存中的地址。在后续章节，我们会介绍指针的相关操作，届时我们会详细介绍这个操作符。

3.1.1 变量名

前面我们说到，我们使用的 age 变量名，在没有任何提示的情况下，大多数人都可以明白 age 变量所代表的含义，这就是本小节我们要说的，C++ 提倡使用有一定含义的变量名。如果变量表示其他的含义，例如：灯光强度（Light intensity）应将其命名为 lightIntensity 或 light_intensity，尽量避免将其命名为 x 或 gq （光强）等易造成混淆的名称。如果将其命名为 li 在特定的、不会引起混淆的代码环境中，可以使用简洁的缩写，但不太推荐在大型项目中单独使用这种极短的缩写，这非常容易引起歧义。

“C++ 必须遵守几个简单的命名规则”中最后一点与前几点有所不同。C++ 标准规定，以两个下划线开头且紧跟一个大写字母的名称（例如 __A、__BIG_CONSTANT 等）是保留给编译器及其使用的资源所使用的。这意味着我们不应该在自己的代码中使用这样的名称，否则可能会导致不可预测的结果，因为编译器可能在不同的阶段使用这些特定的名称来实现其内部的功能，或者与特定的平台相关的实现相关联。如果开发者使用了这些保留名称，可能会与编译器的行为产生冲突，导致编译错误、链接错误或者程序在运行时出现奇怪的行为。

以一个下划线开头的名称（例如 _myVariable、_globalFunction 等）在 C++ 中也有特殊的含义。它们被保留给实现，通常用于全局标识符。这意味着在全局作用域中，我们应该避免使用以单个下划线开头的名称作为自己定义的变量、函数或其他标识符的名称。这样的保留可以确保编译器和链接器在处理程序时不会与开发者定义的名称产生冲突，同时也为实现特定的平台相关功能或编译器内部的实现提供了一定的灵活性。

总之，如果使用我们将不知道会发生什么，但遵循这些命名规则可以避免与编译器和实现相关的名称冲突，提高程序的可移植性和稳定性。

下面是一些 C++ 中有效和无效的名称：

有效的：

• myVariable：由字母开头，后续是字母、数字和下划线的组合，是典型的有效变量名；
• _myVariable1：以单个下划线开头，是有效的，但一般不建议这么用，因为它被保留给实现（虽然通常情况下使用也不会有大问题）；
• myFunction：有效的函数名；
• MyClass：有效的类名；
• inputStream：有明确意义的名称，很常见且有效。

无效的：

• 1myVariable：以数字开头是无效的；
• my Variable：包含空格是无效的；
• my@Variable：包含特殊字符 @ 是无效的；
• int：这是 C++ 的关键字，不能作为标识符名称；
• class：同样是关键字，不能用作名称。

如果想使用两个及以上单词组成一个名称，通常的做法是用下划线将单词分开，例如：my_variable 或者从第二个单词开始将每个单词的第一个首字母大写（即小驼峰命名法），例如：myVariable。C 和 C++ 开发者更倾向于按照 C 语言的风格使用下划线，而 Java 程序员可能更偏向于使用小驼峰命名法。这两种形式都很容易将单词区分开。

3.1.2 整型

我们都知道，整数有无数个，但如果将无限大的整数也包括进来（尽管它确实属于整数）计算机就不可能用有限的内存来表示所有的整数。因此，我们只能表示所有整数的一个子集。C++ 提供多个整数类型，以便能根据具体要求选择使用最合适的整数类型。

C++ 基本整数类型分别有以下几种：

1. char：
   通常是 1 个字节大小，可以表示字符，也可以作为小范围的整数类型使用。有符号的 char 类型范围通常是 - 128 到 127，无符号的 char 类型范围是 0 到 255。

2. short（短整型）：
   一般为 2 个字节大小，具体大小和范围取决于编译器和平台。有符号短整型的范围通常在 - 32768 到 32767 之间。

3. int（整型）：
   通常是 4 个字节大小。有符号整数范围通常在 - 2147483648 到 2147483647 之间。是最常用的整数类型之一。

4. long（长整型）：
   在不同的平台上大小可能不同，通常至少为 4 个字节。有符号长整型的范围通常比有符号整型更大。

5. long long（长长整型）^[2]：
   C++11 新增的类型，通常为 8 个字节大小，提供更大范围的整数表示。有符号长长整型的范围通常非常大。

每种整型类型都有有符号和无符号版，有符号类型可以表示正数、负数和零。例如，有符号 int 类型通常的取值范围是 -2147483648 到 2147483647。存储时，最高位（最左边的位）被用作符号位，0 表示正数，1 表示负数。无符号类型只能表示非负整数，即零和正数。例如，无符号 int 类型的取值范围通常是 0 到 4294967295。所有的位都用于存储数值，没有符号位。

有符号类型在发生溢出时，行为通常是未定义的，但在一些情况下可能会以循环的方式处理。例如，有符号 char 类型，如果从最大值继续增加，可能会变为最小值。无符号类型在溢出时，会以循环的方式进行处理。例如，无符号 char 类型从最大值继续增加会变为 0，然后继续增加。有符号类型在进行比较时，会考虑符号。例如，-1 小于 0。无符号类型在比较时只考虑数值大小。如果将一个有符号负数与无符号数比较，有符号数会被隐式转换为无符号数，可能会导致意外的结果。例如，有符号的 -1 转换为无符号数时会变成一个非常大的正数，通常比任何无符号正数都大。

有符号类型在大多数常规的算术运算和需要考虑正负情况的场景中使用，例如，表示温度的变化、计数的增减等。 无符号类型在确定数值一定是非负的时候使用，例如，表示对象的数量、数组的索引等。而在一些特定的算法中，需要利用无符号类型的循环溢出特性来实现特定的逻辑。

可以像使用 int 一样使用这些类型来声明变量：

1
2
3
4
5
6
7
8
9

short age                       //有符号短整型
int temperature                 //有符号整型
long number_of_rows             //有符号长整型
long long coordinate_values     //有符号长长整型

unsigned short age                       //无符号短整型
unsigned int temperature                 //无符号整型
unsigned long population                 //无符号长整型
unsigned long long number_of_particles   //无符号长长整型

当一个数值超过了其对应数据类型的取值范围时，无符号类型变量的值会从 0 重新开始计数。例如，假设 unsigned int 的取值范围是 0 到 4294967295，如果一个无符号整数变量的值为 4294967295，再对其加 1，它会变为 0。当有符号整数类型变量在进行算术运算（如加法、减法等）时发生溢出，结果是未定义行为。在实际运行中，可能出现奇怪的值，或者程序可能出现错误行为甚至崩溃，具体结果取决于编译器和运行环境。例如，对于有符号 8 位整数类型 char，如果其值为 127，再对其进行加 1 操作，结果是不确定的，可能是 -128（在一些编译器中会出现这种结果，因为最高位变为符号位，导致数值变为负数且取了最小值）。

3.1.3 类型的选择

通过上述学习，我们了解到 C++ 提供了大量的数据类型，应使用哪种类型最为合适呢？

通常，int 类型被设置为最“自然”的长度。自然长度(natural size)可以理解为该数据类型在当前编译器、操作系统和硬件平台组合下通常被分配的字节数。它可能是当前编译器、操作系统和硬件平台组合下处理效率最高的长度。如果没有特定需求或强有力的理由去选择其他类型，则我们建议使用 int。

3.1.4 char 类型

char 类型，顾名思义，是为了专门存储字符（字符和数字）而设计的。计算机对于存储数字来说算不了什么，但存储字母则情况不同。编程语言通过使用字母的数值编码解决了这个复杂的问题。因此，char 类型可以说是另外一种整形。它足够长，能够表示目标计算机系统中的所有基本符号（数字、字母、符号等）。实际上，大多系统支持的字符都不超过 256 种，因此一个字节就可以表示所有的符号。虽然 char 通常被用来处理字符，但你也可以将它用作比 short 更小的整形。

通常我们最常用的符号集是美国信息交换标准代码(ASCII, American Standard Code for Information Interchange)字符集。

字符集中的字符用 ASCII 表中的十进制数值编码表示。例如字符 A 的编码为 65，字符 a 的编码为 97。为了方便起见，我们只会记忆码表的一部分规律和个别开头字符，例如：

• 数字 0 - 9 的 ASCII 码是连续的，可以一起记忆，编码范围是 48（‘0’）到 57（‘9’）；
• 大写字母 A - Z 的 ASCII 码也是连续的，范围是 65（‘A’）到 90（‘Z’）；
• 小写字母 a - z 的 ASCII 码同样连续，范围是 97（‘a’）到 122（‘z’）。

不过 ASCII 编码并不能很好的满足国际化需求，C++ 支持的宽字符类型可以存储更多的值。但考虑到大多数读者对于学习难易的接受程度不同，我们只能优先出于简单学习起见，介绍 ASCII 码（也许随着本书的完善，我们会在后续章节对其他编码作出介绍，例如支持中文和其他基本包含所有国际化文字的 Unicode 字符集）。

但我们会在本文后续小节（3.1.4-4 wchar_t）介绍一种 C++ 支持的宽字符 wchar_t 类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>

using namespace std;

int main()
{
    char character;                             //声明 char 类型的 character 变量
    cout << "Please enter a character: ";
    cin >> character;                           //输入一个字符
    cout << character << endl;                  //程序输出输入的字符 第一次结果输出

    int decCharacter = character;               //声明 int 类型的 decCharacter 变量，用于存储字符的十进制值
    int newCharacter = decCharacter + 1;        //声明 int 类型的 newCharacter 变量，用于存储输入字符下一个字符的十进制值
    char nextCharacter = newCharacter;          //将新的结果存储(转换)为 char 类型的值

    cout << "Input characters: " << character << endl;
    cout << "Enter the decimal value of the character: " << decCharacter << endl;
    cout << "The character that is the decimal value of the input character plus one: " << nextCharacter << endl;

    return 0;
}

程序代码3-1使用了 char 类型，我们输入了某一个字符（这里假定我们输入字符 ‘E’），程序将会输出：

1
2
3
4
5

Please enter a character: E
E
Input characters: E
Enter the decimal value of the character: 69
The character that is the decimal value of the input character plus one: F

其运行结果很有趣，我们输入了一个字母，程序会输出该字母而不是对应的字符编码。反之同样，当你尝试输入字符编码后程序也会输出字符编码，而不是字母。这种有趣的现象源于 char 类型。而如果通过断点调试后你会发现，输入时 cin 将 E 转为了 69 存储在内存中，输出时又进行了逆操作。而 cin 和 cout 都是由变量的类型所引导的。如果将 69 存储在 int 变量中，cout 将会把他显示为 69。

在 C++ 中，我们将字符用单引号引起来，例如：char character = 'E';，将字符串用双引号引起来，例如：string str = "Echo";。cout 对象可以处理这两种情况。同时借此我们将会引导大家学习一项 cout 的新特性 —— cout.put() 函数。

3.1.4-1 成员函数^[3] cout.put()

到底什么是 cout.put() 函数？其中为什么会需要“用一个点来点出”函数？

成员函数是一个重要的 C++ 面向对象(OOP)概念。它用于操作类的数据成员并定义对象的行为。

这部分我们会在后续章节类和对象中为大家详细讲解，这里只做点睛之笔（你可以点击 3.1.4-1 成员函数处的上标5，在脚注处我举了一个通俗易懂的成员函数的例子）。

类定义了如何表示和控制数据，成员函数归类所有。例如类 ostream 中有一个叫做 put() 的函数，用于输出字符，但类只能通过特定对象（这里是 cout 对象）来使用成员函数。要通过对象 cout 来使用成员函数，就必须使用点来将对象名和成员函数所连接。这个点（更准确叫句点）被称为成员操作符。而 cout.put() 的意思是通过类对象 cout 访问（或使用）成员 put() 函数。如本段开头所说，我们会在后续章节详细介绍这一点，现在我们接触过的类只有 istream/ostream（iostream），现在你可以通过使用他们的成员函数来熟悉这一概念。

3.1.4-2 char 常量

在 C++ 中字符常量有很多种书写方式。对于常规字符(如字母、标点符号和数字)，最简单的方法是将字符用单引号引起来。这种表示法代表的是字符的数值编码。例如 ASCII 系统中对应的情况：

• ‘A’ 为 65，即字符 A 的 ASCII 码。
• ‘a’ 为 97，即字符 a 的 ASCII 码。
• ‘1’ 为 49，即数字 1 的 ASCII 码。
• ‘!’ 为 33，即字符 ! 的 ASCII 码。
• ’ ’ 为 32，即空格的 ASCII 码。

这种表示方法优于数值编码，它更加清晰，且不需要知道编码方式。如果系统使用的是非 ASCII 编码，则 A 的编码将不是 65 ，但 ‘A’ 表示的仍然是字符 A。

当然有些字符不能直接通过键盘输入到程序当中。例如：在程序中想要输出一个换行，我们并不能通过 Enter 键让字符串进行换行。因为编辑器会把这种操作视为编辑另起一行。再例如：我们不能把双印号用来分割字符串或者对一个词组打引号，因为 C++ 对这些字符提供了一种特殊的含义，第一个双引号代表字符串开始，第二个双引号代表字符串截止，如果字符串中间出现一个双引号，程序将会认为是两个字符串，且第二个字符串没有正常结尾。

但 C++ 提供了一种特殊的表示方法 —— 字符转义，如下表所示。例如：\n 表示换行符，\" 会将双引号作为常规的字符，而不是字符串分隔符。

下面来看看我们如何使用转义字符。

1
2

char escapeChar = '\n';
cout << "Hello" << escapeChar << "World"<< \t <<"\"Here\" we are";

它的输出如下：

1
2

Hello
World    "Here" we are

3.1.4-3 signed char 和 unsigned char

与 int 不同的是 char 在默认情况下既不是没有符号，也不是有符号的。是否有符号是由 C++ 实现决定的，这样编译器开发人员可以最大限度的与硬件属性所匹配。如果 char 有某种特定的行为，你则可以显示的将类型设置为 signed char 或 unsigned char。

例如：当适用于需要表示有符号的小整数的情况，比如在处理一些小范围的温度变化值（可能有正有负）、误差值等场景时，可以使用 signed char 来存储温度的变化量（假设精度合适）。而当用于存储原始字节数据，比如图像、音频等文件的字节流数据。因为这些数据通常是无符号的字节序列，用 0～255 表示不同的颜色强度（在图像中）或者音频样本的幅度时，可以存储在 unsigned char 类型的变量中。

3.1.4-4 wcha_t

wchar_t 是 C++ 中的宽字符类型。它用于表示比普通字符（char）更宽的字符编码，主要是为了处理 Unicode 字符或其他多字节字符集。在一些需要处理国际化文本（如包含多种语言字符）的程序中非常有用。例如，许多非英语语言有字符不能用单个字节（char）来准确表示，像中文、日文、韩文等语言的字符，这时候就需要使用 wchar_t 来存储。

wchar_t 的大小不是固定的，它取决于编译器和操作系统。在大多数现代系统中，wchar_t 通常占用 2 个字节或者 4 个字节。例如，在 Windows 操作系统下，wchar_t 一般是 16 位（2 个字节），用于存储 UTF-16 编码的字符；而在一些 Unix/Linux 系统中，则可能是 32 位（4 个字节），用于存储 UTF-32 编码的字符。 它存储的是字符的编码值。例如，对于一个 Unicode 字符，其对应的编码会存储在 wchar_t 变量中。如果是 UTF-16 编码，每个 wchar_t 可以存储一个 16-bit 的 Unicode 码点；如果是 UTF-32 编码，每个 wchar_t 可以存储一个 32-bit 的 Unicode 码点。

要声明一个 wchar_t 类型的变量，可以像这样：wchar_t myWideChar;。要定义一个宽字符常量，需要在字符前面加上L前缀。例如：wchar_t wc = L'A'; 表示一个宽字符常量 A。如果要表示一个非英文字符，如汉字“我爱编程”，可以写成 wchar_t chineseChar = L'我爱编程';（这里假设 wchar_t 的大小和编码方式能够正确表示这个汉字）。

而对于宽字符串，可以使用 wcslen（计算宽字符串长度）、wcscpy（复制宽字符串）等函数。这些函数和处理普通字符串（char 类型）的函数类似，但用于宽字符环境。例如：

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
#include <cwchar>

using namespace std;

int main()
{
    wchar_t wstr[] = L"Hello, 世界";
    int length = wcslen(wstr);
    wcout << L"宽字符串长度为: " << length << std::endl;
    return 0;
}

在程序代码3-2中，我们使用 wcslen 函数计算了包括非英文字符在内的宽字符串的长度，wcout 用于输出宽字符流，它类似于 cout，但用于宽字符。

3.1.5 Bool 类型

这里我们只简单介绍 C++ 中布尔值的发展起源，至于使用，我们会在后续章节中多次且重点的使用到，届时我们将会向你着重强调用法及要点。

C++ 语言是在 C 语言的基础上发展而来的。在早期的 C 语言（C89 及以前版本）中没有布尔（bool）类型。C 语言中通常使用整数类型（如int）来表示逻辑值，其中 0 表示假（false），非零值表示真（true）。这种方式虽然能够实现逻辑判断，但在代码的可读性方面存在一定的不足。布尔类型随着 C++ 标准的发展而引入。从 C++98 标准开始，正式添加了 bool 类型。这使得程序员能够更清晰、更符合逻辑地处理布尔值相关的操作。