无符号整数溢出

数字 280 太大，无法容纳在 0 到 255 的 1 字节范围内。比该类型的最大数字 256 大 1。因此，我们将 280 除以 256，得到 1 余数 24。 24 的余数就是存储的内容。

由于每个结构上int的大小不知道，可能是4或者2为了解决这个问题（在移植的时候可能会错误）

有固定宽度的整数:

包含在：

std::int8_t

std::uint8_t

std::int16_t

std::uint16_t

std::int32_t

std::uint32_t

std::int64_t

std::uint64_t

1
2
3
4
5
6
7
8
9
#include <cstdint> // for fixed-width integers
#include <iostream>

int main()
{
    std::int16_t i{5};
    std::cout << i << '\n';
    return 0;
}
1
1.2 x 10⁴` 将写为 `1.2e4
1
5e-2` 相当于 `5 * 10⁻²

请注意，默认情况下，浮点文字默认为 double 类型。 f 后缀用于表示 float 类型的文字。

1
2
3
int x{5};      // 5 means integer
double y{5.0}; // 5.0  double type
float z{5.0f}; // 5.0 is a floating point l
1
2
3
4
5
6
7
8
9
10
11
#include <iostream>

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

	return 0;
}
1
2
3
4
5		//		std::cout 打印了 5，即使我们输入了 5.0。默认情况下，如果小数部分为 0，				std::cout 不会打印数字的小数部分。
5.3
6.7
9.87654e+06

要允许 std::cin 接受“false”和“true”作为输入，必须启用 std::boolalpha 选项：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>

int main()
{
	bool b{};
	std::cout << "Enter a boolean value: ";

	// Allow the user to enter 'true' or 'false' for boolean values
	// This is case-sensitive, so True or TRUE will not work
	std::cin >> std::boolalpha;
	std::cin >> b;

	std::cout << "You entered: " << b << '\n';

        //上面的代码允许你输入true 或者 false
        //下面的代码会输出true 或者 false
    
    std::cout << std::boolalpha;
    bool b1 = 4 ; // copy initialization allows implicit conversion from int to bool
	std::cout << b1 << '\n';

	bool b2 = 0 ; // copy initialization allows implicit conversion from int to bool
	std::cout << b2 << '\n';
}

但是，当启用 std::boolalpha 时，“0”和“1”将不再被解释为布尔输入（它们都解析为“false”，就像任何非“true”输入一样）。

您可以使用 std::noboolalpha 将其关闭。

1
2
3
4
5

if (condition)
  return true;
else
  return false;

这可以用单个语句 return condition 替换。

1
2
3
4
if (height >= 140.0)
  return true;
else
  return false;
1
return (height >= 140.0);

请注意，std::cin 将允许您输入多个字符。但是，变量 ch 只能保存 1 个字符。因此，只有第一个输入字符被提取到变量 ch 中。其余的用户输入保留在 std::cin 使用的输入缓冲区中，并且可以通过后续调用 std::cin 来提取。

显示的类型转换：static_cast 

1
2
3
4
5
6
7
8
9
10
11
12
13
#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;
}
1
2
3
4
5
6
7
8
9
10
11
#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;
}

//a has value 97

要将无符号数转换为有符号数，还可以使用 static_cast 运算符：

1
2
3
4
5
6
7
8
9
10
#include <iostream>

int main()
{
    unsigned int u { 5 };
    int s { static_cast<int>(u) }; // return value of variable u as an int

    std::cout << s << '\n';
    return 0;
}

std::int8_t 和 std::uint8_t 的行为可能类似于字符而不是整数

1
2
3
4
5
6
7
8
9
10
11
12
#include <cstdint>
#include <iostream>

int main()
{
    std::int8_t myInt{65};      // initialize myInt with value 65
    std::cout << myInt << '\n'; // you're probably expecting this to print 65

    return 0;
}

//A

如果要确保 std::int8_t 或 std::uint8_t 对象被视为整数，可以使用 static_cast 将值转换为整数：

1
2
3
4
5
6
7
8
9
10
#include <cstdint>
#include <iostream>

int main()
{
    std::int8_t myInt{65};
    std::cout << static_cast<int>(myInt) << '\n'; // will always print 65

    return 0;
}

如果 std::int8_t 被视为字符，来自控制台的输入也会导致问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <cstdint>
#include <iostream>

int main()
{
    std::cout << "Enter a number between 0 and 127: ";
    std::int8_t myInt{};
    std::cin >> myInt;

    std::cout << "You entered: " << static_cast<int>(myInt) << '\n';

    return 0;
}
1
2
Enter a number between 0 and 127: 35
You entered: 51

这就是发生的事情。当 std::int8_t 被视为字符时，输入例程将我们的输入解释为字符序列，而不是整数。因此，当我们输入 35 时，我们实际上输入了两个字符， '3' 和 '5' 。由于 char 对象只能容纳一个字符，因此会提取 '3' （ '5' 保留在输入流中以供稍后提取）。因为字符 '3' 的 ASCII 代码点为 51，所以值 51 存储在 myInt 中，然后我们将其作为 int 打印。