C++ 学习笔记一

使用空参数列表而不是void来指示函数没有参数。
现代机器上的内存通常被组织成字节大小的单元，每个内存字节都有一个唯一的地址。
为了确定特定机器上数据类型的大小，C++ 提供了一个名为sizeof的运算符。sizeof运算符是一个一元运算符，它接受类型或变量作为参数，并返回其大小（以字节为单位）。您还可以sizeof在变量名上使用运算符。
C++ 有4 种主要基本整数类型

类型	最小尺寸
short int	16 bit
int	32 bit
long int	32 bit
long long int	64bit

signed short a；//定义有符号a，但其实多余，默认为有符号
当对两个整数进行除法运算（称为整数除法）时，C++ 总是产生整数结果。由于整数不能包含小数，因此小数部分将被直接丢弃（不进行四舍五入！）。
如果无符号值超出范围，则将其除以比该类型最大数字大一的数字，并且只保留余数。任何大于该类型可表示的最大数字的数字都会简单地“回绕”（有时称为“模回绕”）。
在保存数量（即使数量应该是非负的）和数学运算时，优先使用有符号数而不是无符号数。避免混合使用有符号数和无符号数。
固定宽度的整数（#include<cstdint>）,保证在任何体系结构上具有相同的大小。

name	type	range
std::int8_t	1 字节有符号	-128 至 127 在许多系统上被视为有符号字符。请参阅下面的注释。
std::uint8_t	1 字节无符号	0 至 255 在许多系统上被视为无符号字符。请参阅下面的注释。
std::int16_t	2字节有符号	-32,768 至 32,767
std::uint16_t	2字节无符号	0 至 65,535
std::int32_t	4字节有符号	-2,147,483,648 至 2,147,483,647
std::uint32_t	4 字节无符号	0 至 4,294,967,295
std::int64_t	8 字节有符号	-9,223,372,036,854,775,808 至 9,223,372,036,854,775,807

如果您使用固定宽度的整数，在某些体系结构上，它可能比更宽的类型慢。例如，如果您需要一个保证为 32 位的整数，您可能会决定使用std::int32_t，但您的 CPU 在处理 64 位整数时实际上可能更快。但是，仅仅因为您的 CPU 可以更快地处理给定类型并不意味着您的程序总体上会更快——现代程序通常受内存使用量而不是 CPU 的限制，更大的内存占用可能会比更快的 CPU 处理加速您的程序更慢。
快速和最小整数

快速类型：（std::int_fast#_t 和 std::uint_fast#_t）提供最快的有符号/无符号整数类型，宽度至少为 # 位（其中 # = 8、16、32 或 64）。例如，std::int_fast32_t将为您提供最快的有符号整数类型，宽度至少为 32 位。最快是指 CPU 可以最快处理的整数类型。
最小类型：std::int_least#_t 和 std::uint_least#_t）提供宽度至少为 # 位（其中 # = 8、16、32 或 64）的最小有符号/无符号整数类型。例如，std::uint_least32_t将为您提供宽度至少为 32 位的最小无符号整数类型。

#include <cstdint> // for fast and least types
#include <iostream>

int main()
{
	std::cout << "least 8:  " << sizeof(std::int_least8_t) * 8 << " bits\n";
	std::cout << "least 16: " << sizeof(std::int_least16_t) * 8 << " bits\n";
	std::cout << "least 32: " << sizeof(std::int_least32_t) * 8 << " bits\n";
	std::cout << '\n';
	std::cout << "fast 8:  " << sizeof(std::int_fast8_t) * 8 << " bits\n";
	std::cout << "fast 16: " << sizeof(std::int_fast16_t) * 8 << " bits\n";
	std::cout << "fast 32: " << sizeof(std::int_fast32_t) * 8 << " bits\n";

	return 0;
}

缺点
首先，实际上使用它们的程序员并不多，而且不熟悉可能会导致错误。其次，快速类型可能会导致内存浪费，因为它们的实际大小可能大于其名称所指示的大小。更严重的是，由于快速/最小整数的大小可能会有所不同，因此您的程序可能会在它们解析为不同大小的体系结构上表现出不同的行为。

科学计数法

由于在 C++ 中输入或显示指数可能很困难，我们使用字母“e”（有时为“E”）来表示等式的“乘以 10 的幂”部分。例如，1.2 x 10⁴将写为1.2e4，而5.9722 x 10²⁴将写为5.9722e24。
对于小于 1 的数，指数可以为负数。该数5e-2相当于5 * 10⁻²，即5 / 10²，或0.05。电子的质量为9.1093837e-31 kg。

有效数字

有效数字（e 之前的部分）中的数字称为有效数字（或有效数字）。有效数字越多，数字越精确。3.14159可以写为3.14159e0。由于有效数字有 6 个数字，因此该数字有 6 个有效数字。

浮点数

浮点数据类型始终是有符号的（可以保存正值和负值）。

类型	typical size
float	4 bytes
double	8bytes
long double	8,12,16bytes

使用浮点文字时，始终至少包含一位小数（即使小数为 0）。这有助于编译器理解该数字是浮点数，而不是整数。

int a { 5 };      // 5 means integer
double b { 5.0 }; // 5.0是一个浮点字面值(默认情况下没有后缀意味着双精度类型)
float c { 5.0f }; // 5.0是浮点文字，后缀f表示浮点类型

int d { 0 }       // 0 is an integer
double e { 0.0 }  // 0.0 is a double

示例

#include <iostream>

int main()
{
	std::cout << 5.0 << '\n';
	std::cout << 6.7f << '\n';
	std::cout << 9876543.21 << '\n';

	return 0;
}


输出结果

5
6.7
9.87654e+06

输出浮点数时，std::cout默认精度为 6 ，也就是说，它假定所有浮点变量都只有 6 位数字（浮点数的最小精度），因此它将截断此后的任何内容。
浮点数有两种特殊类别。第一种是Inf，表示无穷大。Inf 可以是正数或负数。第二种是NaN，代表“非数字”。

布尔值

布尔变量是只能具有两个可能值的变量：true和false。

bool b1 { true };
bool b2 { false };
b1 = false;
bool b3 {}; // default initialize to false

布尔值实际上并不以单词“true”或“false”的形式存储在布尔变量中。相反，它们被存储为整数：true变为整数1，false变为整数0。同样，当布尔值被求值时，它们实际上并不是求值为“true”或“false”。它们求值为整数0（false）或1（true）。因为布尔值实际上存储的是整数，所以它们被认为是整数类型。

如果你希望 std::cout 打印“true”或“false”而不是 0 或 1，则可以使用std::boolalpha。
#include <iostream>

int main()
{
    std::cout << true << '\n';
    std::cout << false << '\n';

    std::cout << std::boolalpha; // print bools as true or false

    std::cout << true << '\n';
    std::cout << false << '\n';
    return 0;
}

您可以使用std::noboolalpha将其关闭。
为了允许std::cin接受“false”和“true”作为输入，必须启用std::boolalpha选项

当使用 std::cout 打印字符时，std::cout 将 char 变量输出为 ASCII 字符

默认情况下，小数部分为 0 的浮点值打印时不带小数位（例如5.0打印为5）。
某些类型转换始终是安全的（例如转换int为double），而其他类型转换可能会导致转换过程中值发生变化（例如转换double为int）。不安全的隐式转换通常会生成编译器警告，或者（在括号初始化的情况下）生成错误。这是括号初始化是首选初始化形式的主要原因之一。括号初始化将确保我们不会尝试使用在隐式类型转换时会丢失值的初始化器来初始化变量

static_cast 运算符进行显式类型转换static_cast<新类型>(表达式)

只要您看到 C++ 语法（不包括预处理器）使用尖括号 (<>)，尖括号之间的内容很可能是类型。这通常是 C++ 处理需要参数化类型的代码的方式。

#include <iostream>

void print(int x)
{
	std::cout << x << '\n';
}

int main()
{
	print( static_cast<int>(5.5) ); // explicitly convert double value 5.5 to an int

	return 0;
}
-------------------------------------------
#include <iostream>

int main()
{
    char ch{ 97 }; // 97 is ASCII code for 'a'
    std::cout << ch << " has value " << static_cast<int>(ch) << '\n'; // print value of variable ch as an int

    return 0;
}
值得注意的是，static_cast的参数求值为表达式。当我们传入一个变量时，该变量将被求值以产生其值，然后该值将转换
为新类型。变量本身不会受到将其值转换为新类型的影响。在上述情况下，变量ch仍然是 char，即使我们将其值转换为
 ，它仍保持相同的值int。