《C++Primer》-1-前序与基础第I部分重点

extern int i; // 声明i并非定义i
int j; 				// 声明并定义j
extern double pi = 3.1415;	// 定义, 注意不要在函数体内部这样做
1
2
3

int a = 10;
int &b = a;
int *c = &b;			// 指针c 指向b
1
2
3

int a = 10;
int &b = a;
int &*c = &b;			// 编译错误
1
2
3

int *p1, p2;		// p1是指针，p2是int类型
int* p1, p2; 		// 与上面相同，但是可能会产生误导，认为p1、p2都是指针
1
2

extern const int bufSize = func();		// 使用一个函数赋值会更加灵活（相对于一个字面量）
1

extern const int bufSize;			// 将上面的定义导出，其他文件才能够使用
1

#include 
using namespace std;

int main() {
    double dval = 3.14;
    const int &ri = dval;       // 使用int的引用去指向一个double，借助const
    cout << ri << endl;					// 3
    ri = 4;                     // 编译报错，ri是一个const不可修改
    return 0;
}
1
2
3
4
5
6
7
8
9
10

double dval = 3.14;
const int temp = dval;				// 使用中间变量，或者官方叫法是临时量(书p55)
const int &ri = temp;       
1
2
3

const double pi = 3.14;
double *ptr = π				// 错误，不能是一个普通指针
const double *ptr = &p1; 	// 正确，但是不能通过ptr指针去改pi的值，这与pi是否是常量无关只与自己的定义const有关
1
2
3

int num = 0;
int *const curErr = #		// curErr将一直指向num
1
2

const double pi = 3.14;
const double *const p = π		// 两者都是const，指向常量对象的常量指针
1
2

const int a = 20; 			// 是
const int b = a+10;			// 是
int c = 30; 						// 不是常量
const int d = get_d();	// 不是，运行期才知道
1
2
3
4

#include 
using namespace std;

int main() {
    constexpr int mf = 20;
    constexpr int limit = mf+10;     
    constexpr int sz = size();      // size函数必须是一个constexpr函数
}
1
2
3
4
5
6
7
8

#include 
using namespace std;

int main() {
    const int *p = nullptr;             // 指向常量的指针
    constexpr int *p2 = nullptr;        // 常量指针
    constexpr const int *p3 = nullptr;  // 指向常量的常量指针
}
1
2
3
4
5
6
7
8

string s;
int n = -1;
while (s.size()

#include 
#include 
using namespace std;

int main() {
    string s;
    cin >> s;
    for (int i=0; i

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

4. 类模版

c++有类模版和函数模版，模版是编译器创建类或者函数的一份说明书，编译器根据模版创建类或者函数的过程就叫做实例化

对于类模版来说，需要提供额外的信息指定实例化成为什么类，一般的方式就是通过尖括号

vector ivec;
1

5. 来自vector列表初始化的恶意

有两种初始化的方式：

• 列表初始化，使用{}，列表中填入每个元素，如vector v1{1, 2, 3, 4...}
• 值初始化，使用()，例如vector v1(n)、vector (n, 10)

但是今天看书看到了一个奇葩的编译器推断尝试（p89）：

#include 
#include 
#include 
using namespace std;

int main() {
    vector v1{10, "hi"};    // 等价于 v1(10, "hi")
    for (auto item : v1) {
        cout << item << ",";        // hi,hi,hi,hi,hi,hi,hi,hi,hi,hi,
    }
    cout << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当编译器发现列表初始化的值不是对应的类型的时候（这里就是10与string对不上），那么就会尝试使用默认值初始化，上例刚好第二个元素是string符合，所以就等价于vector v1(10, "hi")

同理，如果是vector v1{10}就等价于vector v1(10)

而vector v1{10, 11}就是表示有10、11这两个数字，因为类型一样所以不会推断

但是这样真的不会很绕吗？？？？个人感觉如果列表初始化的类型不对那么就最好还是直接编译报错吧….

6. c++的vector与go的slice初始化效率择优方式的不同

c++推崇先定一个空vector在不断的添加元素，这样效率更好（即使预先知道了固定大小）

而go是推崇如果预先知道了大小，要先定义大小再填值会比较高效

这俩者的区别还是很大的，看的出来c++动态数组的扩容算法应该是非常高效的

7. c++的!=编程规范

在for循环中，其他语言的判断语句经常会使用<某个上届来判断是否结束，但是c++经常会使用!=来判定，并且我们应该要习惯于这个方式：

#include 
#include 
using namespace std;

int main() {
    string s("some thing");
    for (auto iter = s.begin(); iter != s.end(); ++iter) {
        *iter = toupper(*iter);
    }
    cout << s << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

具体的原因在于：c++的标准库容器中很多都定义了==和!=运算符，但是没有定义<运算符，所以建议都统一使用!=会更好

8. vector的使用注意事项

当使用迭代器迭代遍历vector的时候，任何可能改变vector对象容量的操作（典型的就是push_back）都会使其迭代器失效

9. 兼容c的数组特性

类似于c语言，在用到数组名字的地方，编译器会自动将其替换为指向其首元素的地址

string *p2 = nums; // 等价于 string *p2 = &nums[0];
1

所以使用auto来推断一个数组名（数组变量）时，推断出来的其实是指针类型

但是用decltype还是会推断出一个数组类型，而不是一个指针（也就是上述的替换过程不会发生）

10. 数组的指针与引用：从内向外阅读

直接看例子以及注释中的含义：

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptrs[5];                       // ptrs是含有10个整型指针的数组
    int (*parrary)[5] = &arr;           // parrary指向数组arr（是一个指向arr的指针）  对于数组要由内向外阅读理解
    int (&arrRef)[5] = arr;             // arrRef是arr数组的引用
}
1
2
3
4
5
6

对于数组来说，需要先从内向外再从右向左的阅读理解，对于int (*parrary)[5] = &arr;

首先内部(*parray)表明parray是一个指针，然后再看右边可知parray指向的是一个大小为5的数组，最后左边表明了基本类型是一个int数组（每个元素都是int类型）

例子：int *(&arry)[10] = ptrs;

arry是一个对ptrs的引用/同义词，引用的是一个大小为10的数组，数组的每个元素都是一个指向int类型的指针类型

11. 范围for语句（for range）中想要改变变量值的注意点

范围for语句（for range）中想要改变变量值要使用引用类型，否则修改的只是变量的副本：

#include 
using namespace std;

int main() {
    int ia[5][5];
    int cnt = 0;
    for (auto &row: ia) {           // 注意要用引用
        for (auto &col: row) {
            col = cnt;
            ++cnt;
        }
    }

    for (auto &row: ia) {
        for (auto &col: row) {
            cout << col << ",";
        }
        cout << endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

详细见书本P83，当然如果使用for遍历下标，那么可以直接使用下标的方式修改

同时在上例中因为是二维数组，不使用引用则第一层遍历的变量会自动转换为一维数组的地址，例如：

for (auto row: ia) {           // 不用引用
  for (auto col: row) {					// 无法通过编译，因为row被替换为指向一维数组地址的指针，row是int*类型
    col = cnt;
    ++cnt;
  }
}
1
2
3
4
5
6

第四章 表达式

1. 求值顺序中的未定义表达式

如果没有强烈指明运算顺序，但是都修改了同一变量，那么此表达式就是一个未定义的表达式，编译器先计算谁后计算谁都有可能发生，这样的表达式是不准确的并且没有实际意义的，例如：

int i = f1() * f2();  // f1、f2的执行顺序是未知的，所以也是未定义的
1

#include 
using namespace std;

int main() {
    int i = 0;
    cout << i << " " << ++i << endl;			// i的运算顺序未知，所以这样编写的代码也是无意义的
    return 0;
}
1
2
3
4
5
6
7
8

所以编写代码的表达式的时候，如果涉及公共变量的修改或者IO操作，那么就需要定义好先后顺序，这样才不会出现意外的情况

除此之外，c++中的有四种运算符默认规定了运算顺序：

• &&、||： 短路原则，如果左边能够决定结果，右边就不会继续计算，先左后右
• ?:： 条件运算符
• ,: 逗号运算符

还有很重要的一点：运算对象的求值顺序与运算符的结合律和优先级完全无关：

f()+g()*h()+j()  // 哪个函数先计算与运算符优先级结合律无关
1

所以，在同一个表达式中，一个表达式改变了某个运算对象的值，其他地方就尽量不要再使用这个运算对象

第五章 语句

1. c++与go的switch case区别

• go语言中switch匹配到了某个case，执行完之后不会继续向下执行其他case（即使没写break），会自动结束
• c/c++语言则需要手动写break，否则会继续向下执行

第六章 函数

1. 行参与实参的注意点

• 函数的实参是用来初始化行参的，但是需要注意的是多个实参的计算顺序是由编译器决定的（任意的）
• 函数的返回类型不能是数组类型或者函数类型，但是可以是指向数组或函数的指针

2. 函数的指针传参与传引用参数

c++中更加推崇行参使用引用而非指针：

#include 
using namespace std;

// 传递指针
void reset1(int *ip) {
    *ip = 0;
    ip = 0;         // 只是改变了行参的指针地址，不会改变实参指针
}

// 引用行参（更推荐）
void reset2(int &ip) {
    ip = 0;
} 

int main() {
    int i = 42;
    reset1(&i);
    cout << i << endl;      // 0
    i = 42;
    reset2(i);
    cout << i << endl;      // 0
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

原因在于：

• 引用传参写实参的时候不需要取地址，因为引用就是绑定在同一个变量，在函数中直接当实参使用即可
• 在一些较大的类类型（并且有一些类类型根本不支持拷贝操作）或者容器类型拷贝传递的方式非常低效，所以要尽量使用引用行参的方式

3. 函数一次返回多个值

可以使用引用行参一次返回多个值

例如：find_char函数用于找到某个字符第一次出现的位置并返回该字符出现的总次数

#include 
using namespace std;

string::size_type find_char(const string s, char c, string::size_type &occurs) {   // occurs使用引用行参作为返回值(隐式返回)
    auto ret = s.size();
    for (decltype(ret) i=0; i!=s.size(); ++i) {
        if (s[i] == c) {
            // 更新第一次出现的位置
            if (ret == s.size()) {
                ret = i;
            }
            // 累加出现的次数
            ++occurs;   
        } 
    } 

    return ret;
}

int main() {
    string t = "afrwersdgnmiressss";
    string::size_type occurs = 0;
    cout << find_char(t, 's', occurs) << endl;
    cout << occurs << endl;
    return 0;
}
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
26

4. 数组作为函数参数传递注意事项（p193）

因为数组本身的两个性质，所以也决定了作为参数传递的不同之处：

因为不允许直接拷贝数组，并且数组会在编译期间替换为其首元素地址，所以其实传递数组传递的是数组的指针

以下三个函数的声明等价，行参都是const int*类型的：

void print(const int*);
void print(const int[]);		// 表示是一个int数组
void print(const int[10]);	// 额外声明了数组大小，但是实际传递的不一定
1
2
3

行参数组的大小对于函数调用的实参没有影响

因为对于行参的数组来说不知道传递过来的数组的大小（只有一个数组的首地址），所以最好的处理方式是同时再传递一个指向尾后元素的指针：

void print(const int* beg, const int* end);
1

调用的时候就可以借助于begin和end函数来获取这两个值

当然也可以将第二个参数改为传递数组的大小size

5. 禁止返回局部变量的引用（p201）

c++的编译器没有像go一样的逃逸分析功能，所以局部变量的引用不能return返回，因为在函数调用结束后会被销毁

#include 
using namespace std;

const string &manip() {
    string ret;
    if (!ret.empty()) {
        return ret;         // 报错： 因为局部变量的引用在函数调用结束后会被销毁
    }
    
    return "Empty";         // 报错：也是一个局部临时量
}

int main(int argc, char **argv) {
    cout << manip() << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6. const_cast强制转换在重载中的广泛使用

#include 
#include 
using namespace std;

// 重载函数1，对应于都是常量参数
const string &shortString(const string &s1, const string &s2) {
    cout << "call const shortString" << endl;
    return s1.size() <= s2.size() ? s1 : s2;
}

// 重载函数2，对应非常量参数
string &shortString(string &s1, string &s2) {
    cout << "call shortString" << endl;
    // 直接调用常量函数，但是参数和结果都需要使用const_cast强行转换
    auto &r = shortString(const_cast(s1), const_cast(s2));
    return const_cast(r);
}

int main(int argc, char **argv) {
    string s1 = "abc", s2 = "ab";
    const string s3 = "efg", s4 = "ef";
    
    cout << shortString(s1, s2) << endl;        // call shortString ab
    cout << shortString(s3, s4) << endl;        // call const shortString ef

    return 0;
}
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
26
27

第七章 类

1. 常量成员函数的来龙去脉

在书中定义Sale_data类的成员方法的时候，可以看到如下的定义：

struct Sales_data {
    // 成员函数
    string isbn() const { return bookNo; }      // 函数体直接定义在类内
    ...
};
1
2
3
4
5

其中较为疑惑的一点在于isbn()函数参数列表之后居然又写了一个const常量标记

这里的作用在于：

• 会用this隐性的代指当前类的对象，其默认的类别为Sales_data* const，也就是指向Sales_data类的一个常量指针
• 但是某些情况下，我们初始化创建的Sales_data对象是一个常量对象即它的类型是const Sales_data,这样的话上述的this就无法涵盖这样的情况，导致无法调用此isbn()函数
• 所以，为了更好的适配性、灵活性以及this是一个隐性参数的原因，c++提供了这样的写法，可以将this的类别最终变成const Sale_data* const，这样的函数也就称之为常量成员函数

2. 类中函数成员与参数同名情况分析

见以下一段代码：

typedef int pos;
pos height;                 // 最外层的height
class dummy
{
private:
    /* data */
public:
   
   pos cursor, width, height;           // 成员height
   void dummy_fcn(pos height) {         // 参数height
        cursor = height * width;        // 这个height是那个height?
   }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

注意：其中成员函数体内的height是参数height而不是类的成员height

如果想使用成员height，则需要改为如下的写法：

void dummy_fcn(pos height) {
  cursor = this->height * width;     
  // 或者 
  // cursor = dummy::height * width;
}
1
2
3
4
5

但其实最好的方法还就是不用将函数参数与成员同名，这样就避免了最初的麻烦

如果想使用最外层的height，则需要改为如下写法：

void dummy_fcn(pos height) {         	// 参数height
  cursor = ::height * width;      		// ::使用作用域运算符显示指定使用最外层的height
}
1
2
3

3. 使用默认初始化初始化一个对象而非声明一个函数(p263)

Sale_data是一个自定义的类，实现了默认初始化的构造函数

如下代码：

Sale_data obj();		// 创建了一个返回类似是Sale_data的空参数函数声明
obj.isbn();					// 将会报错，因为obj是一个函数而不是一个对象			

// 正确的写法（使用默认初始化）：
Sale_data obj;
1
2
3
4
5