【C++ Primer Plus】第3章 处理数据

【信息存储】

程序将找到一块能够存储整数的内存，将该内存单元标记为braincount，并将5复制到该内存单元中；然后，您可在程序中使用braincount来访问该内存单元。

int braincount{5};
int braincount = {5};
int braincount = 5;        //存储一个整数，并使用名称braincount来表示该整数的值

【变量命名规则】

1. 在名称中只能使用字母字符、数字和下划线（_）。
2. 名称的第一个字符不能是数字。
3. 区分大写字符与小写字符。
4. 不能将C++关键字用作名称。
5. 以两个下划线或下划线和大写字母打头的名称被保留给实现（编译器及其使用的资源）使用。 以一个下划线开头的名称被保留给实现，用作全局标识符。
6. C++对于名称的长度没有限制，名称中所有的字符都有意义，但有些平台命名方案有长度限制。

【整型变量的长度】

1. short至少16位；
2. int至少与short一样长；
3. long至少32位，且至少与int一样长；
4. long long至少64位，且至少与long一样长。

可以使用sizeof()函数查看各数据类型在内存中占多少个字节

#include 
#include 	//定义了符号常量来表示类型的限制
 
int main(void)
{
	int n_int = INT_MAX;
	short n_short = SHRT_MAX;
	long n_long = LONG_MAX;
	long long n_llong = LLONG_MAX;
 
	//sizeof不是函数，是运算符。sizeof查看类型所占用的内存大小必须加括号，查看变量可以不加括号。
	
    cout << "int is " << sizeof(int) << " bytes." << endl;
    cout << "Maximum values: " << n_int << endl;
    cout << "short is " << sizeof n_short << " bytes." << endl;
    cout << "Maximum values: " << n_short << endl;
    cout << "long is " << sizeof(long) << " bytes." << endl;
    cout << "Maximum values: " << n_long << endl;
    cout << "long long is " << sizeof n_llong << " bytes." << endl;
    cout << "Maximum values: " << n_llong << endl;
 
	return 0;
}

输出：

整型从最小到最大依次是：

bool、 char、 signed char、unsigned char、 short、 unsigned short、 int、 unsigned int、 long、 unsigned long以及C++11新增的long long和unsigned long long。 

为什么C++有多种整型？

有多种整型类型，可以根据特定需求选择最适合的类型。 例如，可以使用short来存储空格，使用long来确保存储容量，也可以寻找可提高特定计算的速度的类型。

【整型溢出】

int main(void)
{
	short sam = SHRT_MAX;
	unsigned short sue = sam;
 
	cout << "short sam = SHRT_MAX;\t unsigned short sue = sam;" << endl;
	cout << "sam = " << sam << ",\t\t sue = " << sue << endl;
 
	sam = sam+1;    //溢出
	sue = sue+1;
 
	cout << "sam +1 = " << sam << ",\t sue + 1 = " << sue << endl;
 
	return 0;
}

输出：

原因：

该程序将一个short变量（sam）和一个unsigned short变量（sue）分别设置为最大的short值，在我们的系统上，是32767。然后，将这些变量的值都加1。这对于sue来说没有什么问题，因为新值仍比无符号整数的最大值小得多；但sam的值从32767变成了-32768！ 同样，对于sam，将其设置为0并减去1， 也不会有问题； 但对于无符号变量sue，将其设置为0并减去后，它变成了65535。可以看出，这些整型变量的行为就像里程表。如果超越了限制，其值将为范围另一端的取值（参见图3.1）。C++确保了无符号类型的这种行为； 但C++并不保证符号整型超越限制（上溢和下溢）时不出错，而这正是当前实现中最为常见的行为。

 【cout输出同一数据的不同进制表达形式】

#include 
 
using namespace std;
 
int main(void)
{
	int a;
	cout << "请输入一个整数 a = ";
	cin  >> a;
	cout << oct << "a 的8进制：" << a << endl; 
	cout << hex << "a 的16进制：" << a << endl;
	cout << dec << "a 的10进制：" << a << endl; //默认也是十进制输出
 
	return 0;
}

输出：

【char字符在内存中的存储和读取】 

#include 
 
using namespace std;
 
int main(void)
{
	char ch = 'M';	//在内存中ch是以ASCII码值77存储
	int i = ch;	//并没有类型不匹配，把ch内存中的77读取出来赋给整型
 
	//cout发现ch是char类型，就把内存中的77变为对应的字符显示出来
	cout << "The ASCII code for " << ch << " is " << i << endl;
 
	ch = ch+1;
	i = ch;
 
	cout << "ch + 1 后：" << endl;
	cout << "The ASCII code for " << ch << " is " << i << endl;
 
	cout.put('M');    //通过类对象cout来使用函数put( )
	cout << endl;
	cout << 'M' << endl;
 
	return 0;
}

输出：

如何使用C++来找出编码88表示的字符？

char c = 88;
cout << c << endl; // char type prints as character
cout.put(char(88)); // put() prints char as character
cout << char(88) << endl; // new-style type cast value to char
cout << (char)88 << endl; // old-style type cast value to char

【浮点数的表示】

        1、小数点的形式；例如：float a=12.345;
        2、E表示法；例如：float a=1.2e-10;

C和C++对于有效位数的要求是，float至少32位，double至少48位，且不少于float，long double至少和double一样多。这三种类型的有效位数可以一样多。然而，通常，float为32位，double为64位，long double为80、96或128位。另外，这3种类型的指数范围至少是-37到37。

常量为float类型，请使用f或F后缀。对于long double类型，可使用l或L后缀（由于l看起来像数字1，因此L是更好的选择） 。

auto b = 8.25f / 2.5;    //2.5默认double，则b也是double类型。
auto a = 12.345678L;    //a默认为long double类型
 
cout << a << endl;    //输出为12.3456，因为浮点数在系统中只显示了6位有效位

 【double和float精度之间的差异】 

#include 
 
using namespace std;
 
int main(void)
{
	cout.setf(ios_base::fixed, ios_base::floatfield);	//浮点数显示到小数点后六位
 
	float tub = 10.0 / 3.0;
	const float million = 1.0e6;	//定义一个float类型的[常量]
 
	cout << "tub = " << tub << endl;
	cout << "A million tubs = " << tub * million << endl;
 
	double mint = 10.0 / 3.0;
    cout << "mint = " << mint << endl;
    cout << "A million mint = " << mint * million << endl;
 
	return 0;
}

输出：

原因：

tub和mint都被初始化为10.0/3.0—3.333333333333333333……由于cout打印6位小数， 因此tub和mint都是精确的。 但当程序将每个数乘以一百万后， tub在第7个3之后就与正确的值有了误差。 tub在7位有效位上还是精确的（该系统确保float至少有6位有效位， 但这是最糟糕的情况） 。 然而， double类型的变量显示了13个3， 因此它至少有13位是精确的。 由于系统确保15位有效位， 因此这就没有什么好奇怪的了。 另外， 将tub乘以一百万， 再乘读取包含文件以10后， 得到的结果不正确， 这再一次指出了float的精度限制。

【浮点数在内存中的存储方式】

通常float为32位（二进制），float至少有6位有效位（十进制）。

例如：8.25在内存中的表示：
整数部分：1000
小数部分： 01
                   0.25*2=0.5     ---  0
                   0.5*2  =1        ---  1
8.25的二进制表示为：1000.01
8.25的二进制科学计数法表示为：1.00001*(2^3)
符号位：0（正数为0，负数为1）
指数：127（固定偏移）+3 = 130  ----> 10000010（130的二进制）
小数：00001
所以合起来8.25在内存中表示为：0 10000010 00001000000000000000000

一位符号位 + 23位小数位 = 24位二进制数据位 ---> 6位十进制数据位

【浮点运算的速度通常比整数运算慢，且精度将降低】

#include 
 
using namespace std;
 
int main(void)
{
	float a = 2.34e22;
	float b = a + 1.0;
 
	cout << "a = " << a << endl;
	cout << "b = a + 1.0 = " << b << endl;
	cout << "b - a = " << b-a << endl;	//=0，按理说应该=1的。但是......
 
	/*2.34E+22是一个小数点左边有23位的数字。加上1，就是在第23位加1。
	但float类型只能表示数字中的前6位或前7位，因此修改第23位对这个值不会有任何影响。*/
 
	return 0;
}

输出：

【算术运算符】

1. + 运算符对操作数执行加法运算。例如，4+20等于24。
2. - 运算符从第一个数中减去第二个数。例如，12-3等于9。
3. * 运算符将操作数相乘。例如，28*4等于112。
4. / 运算符用第一个数除以第二个数。例如，13/5等于2。
   如果两个操作数都是整数， 则结果为商的整数部分。例如，17/3等于5，小数部分被丢弃（不进行四舍五入）。
   其中一个是浮点数，结果也是浮点数。例如，17.0/3等于5.66667（四舍五入，六位有效数字）。
5. % 运算符求模。也就是说，它生成第一个数除以第二个数后的余数。例如，19%6为1，因为19是6的3倍余1。两个操作数必须都是整型，将该运算符用于浮点数将导致编译错误。如果其中一个是负数，则结果的符号满足如下规则：(a/b)*b + a%b ＝ a。

优先级：类似于数学运算。 

【强制类型转换】

1. (typeName) value;
2. typeName (value);
3. Static_cast (value);

以上三种方法都可以，例如：

cout << (int) 12.6 <//把12.6强制转换成int类型，只截取整数部分，输出12
cout << float (12.3456789) <//把12.3456789强制转换成float类型，四舍五入，输出12.3457

将long值赋给float变量在数值范围内会导致舍入误差。
而把浮点数赋值给整数在数值范围内只会截取整数部分，不进行四舍五入。

【转义字符】

【ASCII码】