C++ Primer 5th 阅读笔记：变量和基本类型

2023/5/4 1:23:20

编程Tag： C++

本文主要是介绍C++ Primer 5th 阅读笔记：变量和基本类型，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一些语言的公共特性

内建类型，如整型，字符型等；
变量，为值绑定的一个名字；
表达式和语句，操作值。
分支和循环，允许我们条件执行和重复执行；
函数，定义抽象计算单元。

扩展语言的方式

自定义类型；
标准库。

本章重点

学习语言的基本知识和标准库。

内建类型；
简要介绍自定义类。

类型

定义了数据的意义；
定义了数据的操作；

从二进制的角度看，类型定义了数据占用几个 bit，以及如何解释这些 bit。

基本内建类型

算术类型
- 整型
- 字符型
- 布尔型
- 浮点型
特殊类型：void

算术类型

整型 (integral types)
- bool: 两个值 true，false。
- char：可以包含 basic character set 中的字符对应的数字。大小等于一个机器字节(single machine byte)。
- wchar_t，char16_t，char32_t。用于 extended character sets。
  wchar_t 可以包含最大 extended character sets 中字符对应的数字。（Windows 2 字节；Unix 4 字节）
  char16_t，char32_t 用于 Unicode 字符。

有关 char 的进一步讨论，见 Byte是8位吗？—C语境中的Byte及C语言的char类型

浮点型 (ﬂoating-point types)
标准没有定义具体的数据格式。一般使用的都是 IEEE 格式。

关于浮点数的详细介绍可见：IEEE 754浮点数标准详解

符号

有符号：signed int/int，signed short/short，signed long/long，signed long long/long long，signed char。
标准没有定义具体的数据格式。一般为补码。
无符号：unsigned int/unsigned，unsigned short，unsigned long，unsigned long long，unsigned char。
特殊：char 有无符号看编译器的实现。

算术类型的经验法则

不包含负数，使用无符号数。
使用 int 来进行整数运算。 short 太小，long 一般和 int 一样大。如果数字太大使用 long long。
不要在算术运算中使用 char 和 bool。可以在算术运算中使用 signed char 和 unsigned char。
浮点数运算使用 double。float 精度有限且带来执行效率上的提升不大。long double 的计算开销过大，一般不使用。

类型转换

赋值语句

左值类型：bool
右值类型：非 bool
转换规则：0 -> false, ≠0 -> true
左值类型：非 bool
右值类型：bool
转换规则：false -> 0, true -> 1
左值类型：整型
右值类型：浮点型
转换规则：f -> int(f)
左值类型：浮点型
右值类型：整型
转换规则：z -> z.00
左值类型：无符号数
右值类型：超出范围的数
转换规则：n -> n % N；n 是超出范围的数， N 是无符号类型能表示的所有值的个数

表达式

如果在算数表达式中同时出现 有符号数 和 无符号数，所有 有符号数 转换为 无符号数。

一例无限循环的错误代码，

// WRONG: u can never be less than 0; the condition will always succeed
for (unsigned u = 10; u >= 0; --u)
	std::cout << u << std::endl

有关 有符号数 和 无符号数 的一些资料：

c++ - Adding two unsigned char variables and result is int - Stack Overflow

C++中在什么情况下使用无符号类型，为什么？ - 知乎

C++有符号和无符号之间的转换 - 知乎

给一个无符号数赋值一个负数,并且该负数绝对值上溢,编译器是如何处理的呢? - 知乎

未定义的行为和实现定义的行为

避免未定义的行为(undefined behavior)和实现定义的行为(implementation-defined behavior)。使用这些行为可能造成程序不可移植(nonportable)。

建议参考以下的文章：

C++中的"未定义的行为"

C++ 未定义行为

C++程序员需要知道的未定义行为

字面量

整型

整数 20 的三种表示法

十进制：20
八进制：024， 0 开头
十六进制：0x14，0x 开头

十进制字面量默认都是 有符号数。
八进制和十六进制则可以为 有符号数 或者 无符号数。
十进制字面量的类型为 int，long，long long 中可以容纳字面量值的最小类型。
八进制和十六进制的类型为 int，unsigned int，long，unsigned long，long long，unsigned long long 中可以容纳字面量值的最小类型。

如果最大类型也不能容纳字面量，则将引起一个错误。

注意： -42 不是字面量，42 才是字面量，- 在其中作为相反数的操作符。

浮点型

浮点数的字面量包含了小数点或者指数（使用科学计数法）。指数使用 e 或者 E 来表示。

3.14159
3.14159E0
0.
0e0.001

科学记数法的形式是由两个数的乘积组成，aEb = a×10^b。

浮点型字面量的默认类型是 double。

字符和字符串字面量

字符字面量，包含在单引号中的一个字符 'a'；
字符串字面量，包含在双引号中的 0 个或多个字符 "abcd"。

字符串字面量是一个字符数组，每个字符串字面量的最后都会有一个 零字符 '\0'(null character)。

多个相邻的字符串字面量会被自动拼接成一个字符串字面量，比如，

// multiline string literal
std::cout << "a really, really long string literal "
             "that spans two lines" << std::endl;

转义序列

转义序列用于表示 非打印字符 或者有特殊含义的字符（如，单引号、双引号）。

转义序列使用 \ 开头。

一般化的转义序列：

\ 后面跟 1 到 3 个八进制数字（0-7）；
\x 后面跟 1 或者多个十六进制数字（0-f）。

注意：

如果 \ 后面跟了四个及以上的八进制数，只有前三个字符会被解释成一般化的转义序列；

如果 \x 后面跟了多个十六进制数，十六进制数会用尽所有的数来表示一个字符。

参考资料:

Escape sequence for ? in c++

字面量类型

我们可以通过添加前缀（针对字符字面量或者字符串字面量）或者后缀（针对整型字面量或者浮点数字面量）的方式来修改默认的字面量类型。

最佳实践：在使用 L 作为后缀时，建议使用大写 L，而不要使用小写 l，目的是为了区分字母 l 和数字 1。
注意：后缀只是指定了字面量能接受的最小类型，如果字面量的值无法被容纳在这个最小类型内，字面量将会尝试下一个更大的类型。

其他字面量

bool 字面量：true 和 false；
指针字面量: nullptr。

参考资料：

c++nullptr（空指针常量）、constexpr（常量表达式）

变量和对象的区别

在本书中的变量和对象没有区别！

变量定义

变量类型指示符(type specifier)
一个或者多个变量名（使用逗号隔开）
2.1. 可以为变量指定一个初始值(可选)
分号 ; 结束

示例：

int sum = 0, value, units_sold = 0;
Sales_item item;
std::string book("0-201-78345-X");

初始化

可以使用之前定的变量来进行初始化；
初始化和赋值在 C++ 中是两个不同的操作；

示例：

double price = 109.99, discount = price * 0.16;
double salePrice = applyDiscount(price, discount);

关于初始化与赋值的区别，可以查看 CSDN 初始化与赋值的区别
对于基本数据类型，二者是没有任何区别，对于非基本数据类型，在写法与效率上有许多不同。

列表初始化

四种初始化的方式：

int units_sold = 0;
int units_sold = {0};
int units_sold{0};
int units_sold(0);

C++11 中使用花括号来初始化内建类型，如果存在类型转换且具有数据丢失的风险，则编译器将会报错。

long double ld = 3.1415926536;
int a{ld}, b = {ld}; // error: narrowing conversion required
int c(ld), d = ld; // ok: but value will be truncated

关于花括号初始化的更多内容，可以参考： C++11 花括号初始化

关于 initializer 的解释，可以参考 Initializers

默认初始化

变量的初始化取决于：

变量的类型
变量定义的位置

内建类型：

定义在函数外的变量会被初始化为 0
定义在函数内的变量不会被初始化（uninitialized)

变量声明(Declaration)和变量定义(Definition)

声明

变量声明指定了变量的类型和名称。

定义

变量定义也是变量声明。
变量定义指定了变量的类型和名称。

变量定义分配存储空间。

变量定义可以指定一个初始值（可选）。

如何声明一个变量？

添加 extern 关键字；
不要提供初始值。

extern int i; // declares but does not define i
int j;        // declares and defines j

任何包含初始值的声明都是定义。

extern double pi = 3.1416; // definition

注意：变量可以被声明多次，但只能被定义一次。

关于声明和定义的参考资料

为什么c++要“在头文件中声明，在源文件中定义”？ - 知乎!

C语言关键字extern详解 - 知乎!

标识符

由字母、数字、下划线组成；
无长度限制；
大小写敏感；

语言保留字

标准库保留字

不能出现两个连续的下划线，如 __i;
不能下划线之后跟着大写字母，如 _I;
函数外的标识符，不能以下划线开头，如：

int _i; // WARNING: DISALLOW!
int main()
{
...
}

关于保留字的参考资料：

C/C++中的保留字_准备开始胡乱学代码的凯的博客-CSDN博客_c++保留字

C++标准库及其保留字(关键字)——附：C++标准文档

命名习惯

名称应符合它的用法；
变量一般是小写字母，如 index；
类名称通常以大写字母开头，如 Sales_item；
名字多个单词之间需要加以区分，
- 下划线命名：student_loan
- 驼峰式命名：studentLoan

关于命名法的参考资料

C语言中变量名及函数名的命名规则与驼峰命名法

变量命名法

四种常用的命名规则：帕斯卡命名法、驼峰命名法、下划线命名法、匈牙利命名法

作用域(Scopes)

每个名称都有自己关联的实体，比如，变量、函数、类型等等。
每个名称都对应的作用域。
作用域一般使用花括号来界定。
相同的名称在不同的作用域中可以关联不同的实体。
名称的可见性从声明的地方开始，直到声明所在作用域的结尾结束。

嵌套作用域(Nested Scopes)

一个作用域可以包含其他作用域。
外部作用域(Outer Scope) 包含了内部作用域(Inner Scope)。
外部作用域中的名字可以被其内部作用域使用。
外部作用域中的名字可以被其内容作用域重新定义。

作用域操作符(`::`)

如果 :: 左侧为空，其代表全局作用域。
我们可以通过作用域操作符来忽视默认的域规则。

复合类型

复合类型是根据另一种类型定义的类型。
复合类型包括：

引用；
指针；
等等。

声明语句是一个基本数据类型(base type) 跟着一组声明符(declarators)。
声明符，一是给了变量的名称，二是给了变量的类型（基于基本数据类型）。

引用

引用定义了变量的一个别名。
引用的声明符格式为: &var。
引用的必须初始化。
引用不可修改。
引用的类型和被引用对象的类型必须匹配（但存在例外）。
引用只能用变量初始化，不能用字面量或者符合表达式。

指针

指针用于间接访问其他元素。
指针本身就是对象。
指针可修改。
指针定义可以不初始化。
指针的声明符格式为: *var。
指针存储了另一个对象的地址。
我们通过取址符&(address-of operator) 来获取对象的地址。
指针的类型和被指向对象的类型必须匹配（但存在例外）。

四种状态

指向一个对象；
指向对象的后面一个位置；
空指针，不指向任何对象；
无效指针。

使用解引用操作符 * 来访问指向的对象。

空指针
空指针不指向任何对象。
空指针的三种表示：

字面量 0
宏定义 NULL
字面量 nullptr(推荐使用)

注意：不能将一个整型变量赋值给指针，即使整型变量的值为 0。

为什么指针难以调试？

指针的值代表一个地址，我们很难区分合法的地址和非法的地址。
建议：初始化所有指针，指向一个具体的对象，或者空指针。
建议：只在被指向的对象定义后，再定义指针。

指针转换到布尔值：

空指针转换为 false；
其他指针转换为 true。

`void*` 指针

void* 指针可以指向任意一个对象。
void* 指针不保存指向对象的类型信息。
我们无法通过 void* 指针操作其指向的对象。

参考资料：

给定一个指针，如何判断这个指针是否已经指向一个合法的对象？

引用和指针的区别

C++：指针与引用的区别

【C++入门】函数重载，引用

复合类型的声明

定义语句是一个基本数据类型(base type) 跟着一组声明符(declarators)。

一个定义中可以定义不同类型的变量。

// i is an int; p is a pointer to int; r is a reference to int
int i = 1024, *p = &i, &r = i;

类型修饰符(type modifier) 仅应用于单个标识符。

定义多个变量的两种风格：

类型修饰符和标识符相邻；

int *p1, *p2; // both p1 and p2 are pointers to int

基本数据类型和类型修饰符相邻。

int* p1; // p1 is a pointer to int
int* p2; // p2 is a pointer to int

`const` 限定符（qualifier）

const 修饰的变量无法被修改。
const 的默认作用域为本文件。因为 C++ 是单独编译每个文件的，我们要将 const 替换为具体的值，需要知道它的定义，所以每一个文件中都包含了 const 的定义，但是不会导致重复定义的情况出现。

如果我们想要在多个文件中共享 const 变量，但是其初始值不是常量表达式（无法在编译阶段获取表达式的值）：

在一个文件中声明 const 变量，需要 extern 关键字
在一个文件中定义 const 变量，需要 extern 关键字。

// file_1.cc defines and initializes a const that is accessible to other files
extern const int bufSize = fcn();

// file_1.h
extern const int bufSize; // same bufSizeas defined in file_1.cc

const 的引用无法修改引用的对象。

const 的引用的初始值可以为，

常量对象；
非常量对象；
字面量；
一般表达式（类型可以不匹配）。

只要初始值可以转换为引用的类型。

double dval = 3.14;
const int &ri = dval;

等价于

double dval = 3.14;
const int temp = dval; // create a temporary const int from the double
const int &ri = temp; // bind ri to that temporary

const 的指针无法修改指向的对象。
const 的指针可以指向非 const 的对象。
const 指针：指针本身无法被修改。
const 指针：必须被初始化。
const 指针的声明，将 const 放在标识符前面，而不是基本数据类型前面。

顶层 const：对象本身是 const，对象本身能否被修改。
底层 const：对象指向的对象是 const，指向对象能否被修改。

对象出现在 = 右侧时，顶层 const 可以被忽略，因为顶层 const 只是阻止对象被修改，但是不阻止对象被拷贝和访问；
对象出现在 = 右侧时，底层 const 必须考虑，因为底层 const 限定了指向对象的操作权限（是否能修改），在拷贝时，只能使得权限不变或者缩小（从可修改到不可修改），反之则不行——可以从 const 到 const 或者 non-const 到 const，但是 const 到 non-const 是不允许的。

参考资料：

extern关键字详解

一分钟了解完C语言中的“ extern”关键字

记录一个非常有趣的题目好强制修改const变量值

通过指针强制修改const变量，这个结果是什么情况？

`constexpr` 和常量表达式

常量表达式是以下几种：

字面量
使用常量表达式初始化的 const 对象
表达式中的所有子表达式都是常量表达式

NOTE:

const 对象不一定都是常量表达式
non-const 对象一定不是常量表达式

const 语义接近 readonly——只读变量； constexpr 的语义接近常量（可以在编译阶段就确定）。

如果你只将变量用作常量表达式，推荐加上 constexpr 关键字。

字面量类型：所有可以使用 constexpr 的类型被称为字面量类型。
字面量类型包括：

算数类型
引用类型
指针类型
其他一些

字面量类型不包括：

Sales_item 类
IO
string 类型

NOTE:当 constexpr 用于指针类型的声明时，constexpr 会添加一个顶层 const。

const int * p = nullptr;  // p is a pointer to a const int
constexpr int * q = nullptr; // q is a const pointer to int

如上的两个语句有不同的语义。

复杂类型

复杂类型的两个特点：

复杂类型很长，写起来容易出错；
复杂类型可能包含很多参数，难以理解它的意义和用途。

参考资料:
C++ const 和 constexpr 的区别？ - Codebowl靓仔的回答 - 知乎
constexpr对编译时间影响大吗？

类型别名

定义类型别名的两种方式

typedef

typedef double wages; // wages is a synonym for double
typedef wages base, *p; // base is a synonym for double, p for double *

typedef 中的类型声明符可以包含类型修饰符，可以用来定义复合类型的别名。

using

using SI = Sales_item; // SI is a synonym for Sales_item
using SP = Sales_item*; // SP is a synonym for Sales_item*

指针类型别名和 const 混用时，别名作为一个基本数据类型出现在声明中，const 是顶层 const，表示对象不可变。

`auto` 关键字，类型指定符

当我们想要通过一个变量来保存表达式的值时，如果遇到表达式值的类型过于复杂，可以使用 auto 关键字来自动推导出变量的类型。
我们可以用 auto 来定义多个变量，多个变量必须有相同的基本数据类型。

auto i = 0, * p = &i; // ok: i is int and p is a pointer to int
auto sz = 0, pi = 3.14; // error: inconsistent types for sz and pi

一些特殊规则：

对于引用类型，auto 会使用引用对象的类型
对于顶层 const，auto 会忽略，对象本身是否可变；如果想要推导出的类型有高层 const，必须显式地指定。
```
const auto f = ci; // deduced type of ci is int; f has type const int
```
对于底层 const，auto 会保留，指向对象是否可变

可以通过 auto 来定义一个引用，引用指向的对象的顶层 const 不会被忽略。

auto &g = ci; // g is a const int& that is bound to ci
auto &h = 42; // error: we can’t bind a plain reference to a literal
const auto &j = 42; // ok: we can bind a const reference to a literal

通过 auto 来定义多个变量时，如果变量包含修饰符，会改变 auto 的推导结果。

指针修饰符：返回表达式指向的对象的类型。顶层 const 保留。
引用修饰符：返回表达式的类型。顶层 const 保留。

auto k = ci, &l = i;
auto &m = ci, * p = &ci;  // m is a const int&; p is a pointer to const int
auto &n = i, * p2 = &ci; // error: type deduced from i is int; type deduced from &ci is const int

`decltype` 关键字，类型指定符

有的时候，我们想用推导出表达式的类型，但是却不想用这个表达式来初始化变量。
decltype 返回操作对象的类型，但是不会对其进行求值。

decltype(f()) sum = x; // sum has whatever type f returns