C++ Primer Plus——第3章 处理数据

面向对象编程的本质是设计并扩展自己的数据类型。设计自己的数据类型就是让类型与数据匹配。
内置的C++类型分两组：基本类型（整数和浮点数）和复合类型（数组、字符串、指针、结构）。

3.1 简单变量

为把信息存储在计算机中，程序必须记录3个基本属性：
（1）信息将存储在哪里
（2）要存储什么值
（3）存储何种类型的信息

int braincount;
braincount = 5;
// 程序将找到一块能够存储整数的内存，将该内存单元标记为braincount，并将5复制到该内存单元中
// 然后，可在程序中使用braincount来访问该内存单元
// 可以使用&运算符来检索braincount的内存地址。

3.1.1 变量名

C++提倡使用具有一定含义的变量名，C++命名规则：
（1）在名称中只能使用字母字符、数字和下划线（_）。
（2）名称的第一个字符不能是数字。
（3）区分大写字符与小写字符。
（4）不能将C++关键字用作名称。
（5）以两个下划线或下划线和大写字母打头的名称被保留给实现（编译器及其使用的资源）使用，以一个下划线开头的名称被保留给实现，用作全局标识符。
（6）C++对于名称的长度没有限制，名称中所有的字符都有意义，但有些平台有长度限制。
如果想用两个或更多的单词组成一个名称，通常的做法是用下划线字符将单词分开，或者从第二个单词开始将每个单词的第一个字母大写。
可在变量名中加入描述变量类型或内容的前缀（n表示整数、str或sz表示以空字符结束的字符串、b表示布尔值、p表示指针、c表示单个字符）

3.1.2 整型

1、整数就是没有小数部分的数字。
2、不同C++整型使用不同的内存量来存储整数，使用的内存量越大，可以表示的整数值范围也越大。
3、有的类型（符号类型）可表示正值和负值，而有的类型（无符号类型）不能表示负值。
4、术语宽度用于描述存储整数时使用的内存量，使用的内存越多，则越宽。
5、C++的基本整型（按宽度递增的顺序排列）分别是char、short、int、long和C++11新增的long long，其中每种类型都有符号版本和无符号版本，因此总共有10种类型可供选择。

3.1.3 整型short、int、long和long long

1、计算机内存由一些叫做位（bit）的单元组成。字节（byte）通常指的是8位的内存单元，字节指的就是描述计算机内存量的度量单位（1KB=1024字节、1MB=1024KB）。C++对字节的定义与此不同，C++字节由至少能够容纳实现的基本字符集的相邻位组成，也就是说，可能取值的数目必须等于或超过字符数目。在美国，基本字符集通常是ASCII和EBCDIC字符集，它们都可以用8位来容纳，所以在使用这两种字符集的系统中，C++字节通常包含8位。然而，国际编程可能需要使用更大的字符集，如Unicode，因此有些实现可能使用16位甚至32位的字节。
2、C++的short、int、long和long long类型通过使用不同数目的位来存储值，最多能够表示4种不同的整数宽度。
（1）short至少16位
（2）int至少与short一样长
（3）long至少32位，且至少与int一样长
（4）long long至少64位，且至少与long一样长
3、sizeof运算符：
（1）返回类型或变量的长度，单位为字节。
（2）可对类型名或变量名使用sizeof运算符，对类型名使用sizeof运算符时，应将名称放在括号中，但对变量名使用该运算符时，括号是可选的。
4、头文件climits

climits文件中包含与下面类似的语句行：

#define INT_MAX 32767

在C++编译过程中，首先将源代码传递给预处理器。#define和#include一样，也是一个预处理器编译指令。该编译指令告诉预处理器：在程序中查找INT_MAX，并将所有的INT_MAX都替换为32767。

// 程序清单3.1 limits.cpp -- some integer limits
#include <iostream>
// 头文件climits中包含了关于整型限制的信息。具体地说，它定义了表示各种限制的符号名称。例如，INT_MAX为int的最大取值，CHAR_BIT为字节的位数
#include <climits>

using namespace std;

int main(void)
{
    int n_int = INT_MAX;
    short n_short = SHRT_MAX;
    long n_long = LONG_MAX;
    long long n_llong = LLONG_MAX;

    cout << "int is " << sizeof(int) << " bytes." << endl;
    cout << "short is " << sizeof n_short << " bytes." << endl;
    cout << "long is " << sizeof n_long << " bytes." << endl;
    cout << "long long is " << sizeof n_llong << " bytes." << endl;
    cout << endl;

    cout << "Maximun values: " << endl;
    cout << "int: " << n_int << endl;
    cout << "short: " << n_short << endl;
    cout << "long: " << n_long << endl;
    cout << "long long: " << n_llong << endl;

    cout << "Minimum int value = " << INT_MIN << endl;
    cout << "Bits per bytes = " << CHAR_BIT << endl;
    return 0;
}

5、初始化：初始化将赋值语句与声明合并在一起（等号右侧为已知）。

int owls = 101;
int wrens(432);
// 使用大括号初始化器进行初始化
// 可以使用等号，也可以不使用
// 大括号内可以不包含任何东西，在这种情况下，变量将被初始化为0
// 有助于更好的防范类型转换错误
// 大括号初始化器可用于任何类型：常规变量/类变量
int hamburgers = {24};
int enums{7};
int rocs = {}; 

6、如果不对函数内部定义的变量进行初始化，该变量的值将是不确定的。这意味着该变量的值将是它被创建之前，相应内存单元保存的值。

3.1.4 无符号类型

1、要创建无符号版本的基本整型，只需使用关键字unsigned来修改声明即可：unsigned short、unsigned int（unsigned）、unsigned long、unsigned long long

// 程序清单3.2 exceed.cpp -- exceeding some integer limits
#include <iostream>
#include <climits>
# define ZERO 0

using namespace std;

int main(void)
{
    short sam = SHRT_MAX;
    unsigned short sue = sam;

    cout << "Sam has " << sam << " dollars and Sue has " << sue << " dollars deposited." << endl;
    cout << "Add $1 to each account." << endl;
    sam = sam + 1;
    sue = sue + 1;
    cout << "Sam has " << sam << " dollars and Sue has " << sue << " dollars deposited." << endl;

    sam = ZERO;
    sue = ZERO;
    cout << "Sam has " << sam << " dollars and Sue has " << sue << " dollars deposited." << endl;
    cout << "Take $1 to each account." << endl;
    sam = sam - 1;
    sue = sue - 1;
    cout << "Sam has " << sam << " dollars and Sue has " << sue << " dollars deposited." << endl;

    return 0;
}

3.1.5 选择整型类型

通常，int被设置为对目标计算机而言最为“自然”的长度，自然长度指的是计算机处理起来效率最高的长度，如果没有非常有说服力的理由来选择其他类型，则应使用int。

3.1.6 整型字面值

1、整型字面值（常量）是显式地书写的常量
2、C++能够以三种不同的计数方式来书写整数：基数为10、基数为8和基数为16。C++使用前一（两）位来标识数字常量的基数。如果第一位为1-9，则基数为10；如果第一位是0，第二位是1-7，则基数为8；如果前两位为0x或0X，则基数为16。

// 程序清单3.3 hexoct.cpp -- shows hex and octal literals
#include <iostream>

using namespace std;

int main(void)
{
    int cheat = 42;
    int waist = 0x42;
    int inseam = 042;

	// 在默认情况下，cout以十进制格式显示整数，而不管这些整数在程序中是如何书写的
	cout << "Monsieur cuts a striking figure!\n";
    cout << "chest = " << cheat << " (42 in decimal)." << endl;
    cout << "waist = " << waist << " (0x42 in hex)." << endl;
    cout << "inseam = " << inseam << " (042 in octal)." << endl;

    return 0;
}

3、无论把值书写成什么格式，都将以相同的方式存储在计算机中——被存储为二进制数。

// 程序清单3.4 hexoct2.cpp -- display values in hex and octal
#include <iostream>

using namespace std;

int main(void)
{
    int cheat = 42;
    int waist = 42;
    int inseam = 42;

	// cout提供了控制符dec、hex、oct，分别用于指示cout以十进制、十六进制和八进制格式显示整数，默认格式为十进制，在修改格式之前，原来的格式将一直有效
    cout << "chest = " << cheat << " (decimal for 42)." << endl;
    // cout << hex不会在屏幕上显示任何内容，而只是修改cout显示整数的方式
    cout << hex;
    cout << "waist = " << waist << " (hexadecimal for 42)." << endl;
    cout << oct;
    cout << "inseam = " << inseam << " (octal for 42)." << endl;

    return 0;
}

3.1.7 C++如何确定常量的类型

1、除非有理由存储为其他类型（如使用了特殊的后缀来表示特定的类型，或者值太大，不能存储为int），否则C++将整型变量存储为int类型。
（1）后缀是放在数字常量后面的字母，用于表示类型。整数后面的l或L后缀表示该整数为long常量，u或U后缀表示unsigned int常量，ul或uL表示unsigned long常量.。
（2）对于不带后缀的十进制整数，将使用下面几种类型中能够存储该数的最小类型来表示：int、long或long long。对于不带后缀的十六进制或八进制整数，将使用下面几种类型中能够存储该数的最小类型来表示：int、unsigned int、long、unsigned long、long long或unsigned long long。这是因为十六进制常用来标会内存地址，而内存地址是没有符号的。

3.1.8 char类型：字符和小整数

1、char类型是转为存储字符（如字母和数字）而设计的。char类型是另一种整型，能够表示目标计算机系统中的所有基本符号——所有的字母、数字、标点符号等。

// 程序清单3.5 chartype.cpp -- the char type
#include <iostream>

using namespace std;

int main(void)
{
    char ch; 

    cout << "Enter a character: ";
    cin >> ch;

	cout << "Hola! ";
    cout << "Thank you for the " << ch << " character." << endl;

    return 0;
}

2、C++对字符用单引号，对字符串使用双引号。

// 程序清单3.6 morechar.cpp - the char type and int type contrasted
#include <iostream>

using namespace std;

int main(void)
{
    char ch = 'M';
    int i = ch;
    cout << "The ASCII code for " << ch << " is " << i << endl;

    cout << "Add one to the character code:" << endl;
    ch = ch + 1;
    i = ch;
    cout << "The ASCII code for " << ch << " is " << i << endl;

    cout << "Displaying char ch using cout.put(ch): ";
    // cout.put()函数，显示一个字符串
    cout.put(ch);

    cout.put('!');
    cout << endl << "Done" << endl;

    return 0;
}

char ch;
cin >> ch; // 如果输入5并按回车，上述代码将读取字符“5”，并将其对应的字符编码（ASCII编码53）存储到变量ch中
int n;
cin >> n; // 如果输入5并按回车，上述代码将读取字符“5”，将其转换为响应的数字值5，并存储到变量n中

3、成员函数cout.put()
（1）成员函数归类所有，描述了操纵类数据的方法。
（2）类ostream有一个put()成员函数，用来输出字符。
（3）只能通过类的特定对象来使用成员函数。要通过对象使用成员函数，必须使用句点将对象名和函数名称连接起来。句点被称为成员运算符。cout.put()的意思是，通过类对象cout来使用函数put()。
（4）cout.put()成员函数提供了另一种显示字符的方法，可以替代<<运算符。
4、char字面值
（1）将字符用单引号括起，这种表示法代表的是字符的数值编码
（2）有些字符不能直接通过键盘输入到程序中——转义序列，应该像处理常规字符那样处理转义序列，将它们作为字符常量时，应用单引号括起；将它们放在字符串中时，不要使用单引号。

（3）下面三行代码都将光标移到下一行开头：

cout << endl;
cout << '\n';
cout << "\n";

（4）可以基于字符的八进制和十六进制编码来使用转义序列。例如，Ctrl+Z的ASCII码为26，对应的八进制编码为032，十六进制编码为0x1a。可以使用下面的转义序列来表示该字符：\032或\x1a。将这些编码用单引号括起，可以得到相应的字符常量，如’\032’。

// 程序清单3.7 bondini.cpp -- using escape sequences
#include <iostream>
int main()
{
	using namespace std;
	cout << "\aOperation \"HyperHype\" is now activated!\n";
	cout << "Enter your agent code:________\b\b\b\b\b\b\b\b";
	long code;
	cin >> code;
	cout << "\aYou entered " << code << "...\n";
	cout << "\aCode verified! Proceed with Plan Z3!\n";
	return 0;
}

5、通用字符名
（1）C++实现支持一个基本的源字符集，即可用来编写源代码的字符集。它由标准美国键盘上的字符（大写和小写）和数字、C语言中使用的符号组成。
（2）C++实现支持一个基本的执行字符集，它包括在程序执行期间可处理的字符（如可从文件中读取或显示到屏幕上的字符）。它增加了一些字符，如退格和振铃。
（3）C++标准还允许实现提供扩展源字符集和扩展执行字符集。
（4）那些被作为字母的额外字符也可用于标识符名称中，C++有一种表示这种特殊字符的机制，它独立于任何特定的键盘，使用的是通用字符名。通用字符名以\u或\U大头。\u后面是8个十六进制位，\U后面是16个十六进制位，这些位表示的是字符的ISO 10646码点。
（5）Unicode提供了一种表示各种字符集的解决方案——为大量字符和符号提供标准数值编码，并根据类型将它们分组。ASCII码为Unicode的子集。Unicode给每个字符指定一个编号——码点。Unicode码点通常类似于下面这样：U-222B。其中U表示这是一个Unicode字符，而222B是该字符的十六进制编号。
6、signed char和unsigned char
char在默认情况下既不是没有符号，也不是有符号，是否有符号由C++实现决定。如果char有某种特定的行为，可以显式地将类型设置为unsigned char或signed char。
7、wcha_t
（1）可以同时支持一个小型的基本字符集和一个较大的扩展字符集。8位char可以表示基本字符集，另一种类型wchar_t（宽字符类型）可以表示扩展字符集。
（2）wchar_t类型是一种整数类型，它有足够的空间，可以表示系统使用的最大扩展字符集。这种类型与另一种整型的长度和符号属性相同，对低层类型的选择取决于实现，因此在一个系统中，它可能是unsigned short，而在另一个系统中，则可能是int。
（3）cin和cout将输入和输出看做是char流，wcin和wcout可用于处理wchar_t流。
（4）通过加上前缀L来指示宽字符常量和宽字符串。

wchar_t bob = L'P';
wcout << L"tall" << endl;

8、C++11新增的类型：char16_t和char32_t
（1）char16_t：无符号，长16位，使用前缀u
（2）char32_t：无符号，长32位，使用前缀U

char16_t ch1 = u'q';
char32_t ch2 = U'\U0000222B'

3.1.9 bool类型

布尔变量的值可以是true或false，C++将非零值解释为true，将零解释为false。

bool is_ready = true;
// 字面值true和false都可以通过提升转换为int类型，true被转换为1，false被转换为0
int ans = true;
int promise = false;
// 任何数字值或指针值都可以被隐式转换为bool值，任何非零值都被转换为true，而零被转换为false
bool start= -100;
bool stop = 0;

3.2 const限定符

1、符号名称指出了常量表示的内容。如果程序在多个地方使用同一个常量，则需要修改该常量时，只需修改一个符号定义即可。
2、使用const关键字来修改变量声明和初始化。

const int Months = 12;

3、常量被初始化后，其值就被固定了，编译器将不允许再修改该变量的值。关键字const叫做限定符，因为它限定了声明的含义。
4、常量的常见命名约定：
（1）将名称的首字母大写
（2）将整个名称大写
（3）以字母k打头
5、如果在声明常量时没有提供值，则该常量的值将是不确定的，且无法修改。
6、const优点：
（1）能够明确指定类型
（2）可以使用C++的作用域规则将定义限制在特定的函数或文件中
（3）可以将const用于更复杂的类型

3.3 浮点数

1、浮点数是能够表示带小数部分的数字，其提供的值的范围更大。
2、C++内部表示浮点数的方法：一部分表示值，另一部分用于对值进行放大和缩小（缩放因子是2的幂）

3.3.1 书写浮点数

1、C++书写浮点数的方式：
（1）使用常用的标准小数点表示法
（2）E表示法：E表示法确保数字以浮点数格式存储，即使没有小数点。注意，既可以使用E也可以使用e，指数可以是正数也可以是负数，数字中不能有空格（d.dddE+n指的是将小数点向右移n位，而d.dddE-n指的是将小数点向左移n位）。

3.3.2 浮点类型

1、C++有三种浮点类型：float、double、long double，这些类型是按它们可以表示的有效位数和允许的指数最小范围来描述的。有效位是数字中有意义的位，有效位不依赖于小数点的位置。
2、C和C++对于有效位数的要求是，float至少32位（二进制），double至少48位，且不少于float，long double至少和double一样多，通常float为32位，double为64位，long double为80、96或128位。这三种类型的指数范围至少是-37到37。

// 程序清单3.8 floatnum.cpp--floating-point types
#include <iostream>

using namespace std;

int main(void)
{
     // ostream方法setf()，这种调用迫使输出使用定点表示法，以便更好地了解精度
     // 它防止程序把较大的值切换为E表示法，并使程序显示到小数点后6位
     // 参数ios_base::fixed和ios_base::floatfield是通过包含iostream来提供的常量
     cout.setf(ios_base::fixed, ios_base::floatfield);
     // 该系统确保float至少有6位有效位，double至少有15位有效位
     float tub = 10.0 / 3.0;
     double mint = 10.0 / 3.0;
     const float million = 1.0e6;

     cout << "tub = " << tub << ", a million tubs = " << million * tub
          << ", and ten million tubs = " << 10 * million * tub << endl;
     cout << "mint = " << mint << ", a million mint = " << million * mint
          << ", and ten million mint = " << 10 * million * mint << endl;

     return 0;
}

3.3.3 浮点常量

在默认情况下，浮点常量都属于double类型。如果希望常量为float类型，请使用f或F后缀；对于long double类型，可使用l或L后缀。

3.3.4 浮点数的优缺点

优点：
（1）可以表示整数之间的值
（2）由于有缩放因子，它们可以表示的范围大得多
缺点：
浮点运算的速度通常比整数运算慢，且精度将降低

// 程序清单3.9 fltadd.cpp--precision problems with float
#include <iostream>

using namespace std;

int main(void)
{
    float a = 2.34E+22f;
    float b = a + 1.0f;

    cout << "a = " << a << endl;
    cout << "b - a = " << b - a << endl;
    //2.34E+22是一个小数点左边有23位的数字。加上1，就是在第23位加1。
    //但float类型只能表示数字中的前6位或前7位，因此修改第23位对这个值不会有任何影响

    return 0;
}

3.4 C++算术运算符

（1）+运算符对操作数执行加法运算
（2）-运算符从第一个数中减去第二个数
（3）*运算符将操作数相乘
（4）/运算符用第一个数除以第二个数，如果两个操作数都是整数，则结果为商的整数部分
（5）%运算符求模，两个操作数必须都是整型，如果其中一个是负数，则结果的符号满足如下规则：(a/b)*b + a%b = a

// 程序清单3.10 arith.cpp--some C++ arithmetic
#include <iostream>

using namespace std;

int main(void)
{
    float hats, heads;

    cout.setf(ios_base::fixed, ios_base::floatfield);
    cout << "Enter a number: ";
    cin >> hats;
    cout << "Enter another number: ";
    cin >> heads;

    // 对于float，C++只保证6位有效位，如果把61.419998（hats=50.25，heads=11.17）四舍五入成6位，将得到61.4200，这是保证精度下的正确值
    cout << "hats = " << hats << " ; heads = " << heads <<endl;
    cout << "hats + heads = " << hats + heads << endl;
    cout << "hats - heads = " << hats - heads << endl;
    cout << "hats * heads = " << hats * heads << endl;
    cout << "hats / heads = " << hats / heads << endl;

    return 0;
}

3.4.1 运算符优先级和结合性

3.4.2 除法分支

除法运算符（/）的行为取决于操作数的类型。如果两个操作数都是整数，则C++将执行整数除法，这意味着结果的小数部分将被丢弃，使得最后的结果是一个整数。如果其中有一个或两个操作数是浮点值，则小数部分保留，结果为浮点数。

// 程序清单3.11 divide.cpp--integer and floating-points division
#include <iostream>

using namespace std;

int main(void)
{
    cout.setf(ios_base::fixed, ios_base::floatfield);

    // 对不同类型进行运算时，C++将把它们全部转换为同一类型
    // 如果两个操作数都是double类型，则结果为double类型；如果两个操作数都是float类型，则结果为float类型
    cout << "Integer division: 9/5 = " << 9 / 5 << endl;
    cout << "Floating_point division: 9.0/5.0 = " << 9.0 / 5.0 << endl;
    cout << "Mixed division: 9.0/5 = " << 9.0 / 5 << endl;
    cout << "double constants: 1e7/9.0 = " << 1.e7 / 9.0 << endl;
    cout << "float constants: 1e7f/9.0f = " << 1.e7f / 9.0f << endl;

    return 0;
}

运算符重载：使用相同的符号进行多种操作

3.4.3 求模运算符

求模运算返回整数除法的余数。

// 程序清单3.12 modulus.cpp--use % operator to convert lbs to stone

#include <iostream>

using namespace std;

int main(void)
{
    const int Lbs_per_stn = 14;
    cout << "Enter your weight in pounds: ";
    int lbs;
    cin >> lbs;
    int stone = lbs / Lbs_per_stn;
    int pounds = lbs % Lbs_per_stn;

    cout << lbs << " pounds are " << stone << " stone, " << pounds << " pound(s)." << endl;

    return 0;
}

3.4.4 类型转换

C++自动执行类型转换的场景：
（1）将一种算术类型的值赋给另一种算术类型的变量时，C++将对值进行转换
（2）表达式中包含不同的类型时，C++将对值进行转换
（3）将参数传递给函数时，C++将对值进行转换
一、初始化和赋值进行的转换：C++允许将一种类型的值赋给另一种类型的变量，值将被转化为接收变量的类型。

// 程序清单3.13 assign.cpp--type changes on initializetions
#include <iostream>

using namespace std;

int main(void)
{
    cout.setf(ios_base::fixed, ios_base::floatfield);

    float tree = 3;
    int guess(3.9832); // 将浮点型转换为整型时，C++采取截取而不是四舍五入
    int debt = 7.2E12; // 越界，结果不可预期

    cout << "tree = " << tree << endl;
    cout << "guess = " << guess << endl;
    cout << "debt = " << debt << endl;

    return 0;
}

二、以{}方式初始化时进行的转换（C++11）
C++11将使用大括号的初始化称为列表初始化，因为这种初始化常用于给复杂的数据类型提供值列表。列表初始化不允许缩窄，即变量的类型可能无法表示赋给它的值。

int x = 66;
char c1 = {x}; // 不允许，在编译器看来，x是一个变量，其值可能很大

x = 31325;
char c2 = x; // 允许但此时已超限，若用列表初始化，则不被允许

三、表达式中的转换
1、一些类型在出现时便会自动转换：在计算表达式时，C++将bool、char、unsigned char、signed char和short值转换为int。
2、有些类型在与其他类型同时出现在表达式中时将被转换：当运算涉及两种类型时，较小的类型将被转换为较大类型
（1）如果有一个操作数的类型是long double，则将另一个操作数转换为long double
（2）否则，如果有一个操作数的类型是double，则将另一个操作数转换为double
（3）否则，如果有一个操作数的类型是float，则将另一个操作数转换为float
（4）否则，说明操作数都是整型，因此执行整型类型提升
（5）在这种情况下，如果两个操作数都是有符号或无符号的，且其中一个操作数的级别比另一个低，则转换为级别高的类型
（6）如果一个操作数为有符号的，另一个操作数为无符号的，且无符号操作数的级别比有符号操作数高，则将有符号操作数转换为无符号操作数所属类型
（7）否则，如果有符号类型可表示无符号类型的所有可能取值，则将无符号操作数转换为有符号操作数所属类型
（8）否则，将两个操作数都转换为有符号类型的无符号版本
四、传递参数时的转换
传递参数时的类型转换通常由C++函数原型控制，也可以取消原型对参数传递的控制，在这种情况下，C++将对char和short类型应用整型提升，将float参数提升为double。
五、强制类型转换
C++还允许通过强制类型转换机制显式地进行类型转换。

// 将存储在变量thorn中的int值转化为long类型
(long) thorn;
long (thorn);
// 强制类型转换不会修改thorn变量本身，而是创建一个新的、指定类型的值，可以在表达式中使用这个值
// C++还引入了4个强制类型转换运算符，对他们的使用要求更为严格
// static_cast<>可用于将值从一种数值类型转换为另一种数值类型
static_cast<long> (thorn)

// 程序清单3.14 typecast.cpp--forcing type changes
#include <iostream>

using namespace std;

int main(void)
{
    int auks, bats, coots;

    auks = 19.99 + 11.99;
    bats = (int) 19.99 + (int) 11.99;
    coots = int (19.99) + int (11.99);

    cout << "auks = " << auks << ", bats = " << bats << ", coots = " << coots << endl;

    char ch = 'Z';
    cout << "The code for " << ch << " is " << int(ch) << endl;
    cout << "Yes, the code is " << static_cast<int>(ch) << endl;
    
    return 0;
}

3.4.5 C++11中的auto声明

C++11新增了一个工具，让编译器能够根据初始值的类型推断变量的类型。在初始化声明中，如果使用关键字auto，而不指定变量的类型，编译器将把变量的类型设置成与初始值相同。

3.5 总结

C++的基本类型分为两组：一组由存储为整数的值组成，另一组由存储为浮点格式的值组成。整型之间通过存储值时使用的内存量及有无符号来区分。整型从最小到最大依次是：bool、char、unsigned char、short、unsigned short、int、unsigned int、long、unsigned long以及C++11新增的long long和unsigned long long。还有一种wchar_t类型，它在这个序列中的位置取决于实现。C++11新增了类型char16_t和char32_t，他们的宽度足以分别存储16和32位的字符编码。C++确保char足够大，能够存储系统基本字符集的任何成员，而wchar_t则可以存储系统扩展字符集的任意成员。short至少为16位，而int至少与short一样长，long至少为32位，且至少和int一样长。确切的长度取决于实现。
字符通过其数值编码来表示。I/O系统决定了编码是被解释为字符还是数字。
浮点类型可以表示小数值以及比整型能够表示的值大得多的值。3种浮点类型分别是float、double和long double。C++确保float不比double长，而double不比long double长。通常，float使用32位内存，double使用64位，long double使用80到128位。
通过提供各种长度不同、有符号或无符号的类型，C++使程序员能够根据特定的数据要求选择合适的类型。
C++使用运算符来提供对数字类型的算术运算：加、减、乘、除和求模。当两个运算符对同一个操作数进行操作时，C++的优先级和结合性规则可以确定先执行哪种操作。
对变量赋值、在运算中使用不同类型、使用强制类型转换时，C++将把值从一种类型转换为另一种类型。很多类型转换都是“安全的”，即可以在不损失和改变数据的情况下完成转换。例如，可以把int值转换为long值，而不会出现任何问题。对于其他一些转换，如将浮点类型转换为整型，则需要更加小心。