文章目录

• 第一章 开始
• • 1. c++之与其他语言的优点？
  • 2. c++语言的组成
  • 3. 标准输入输出cin、cout
  • 4. include格式
• 第二章 变量和基本类型
• • 1. 无符号数的使用注意
  • 2. 初始化注意事项
  • 3. 声明与定义
  • 4. 标识符的下划线规则
  • 5. &引用、取地址&、指针的区别
  • 6. 如何理解“因为引用不是对象，没有实际地址，所以不能定义指向引用的指针”
  • 7. 复合类型的声明
  • 8. 指向指针的引用
  • 9. extern+const让常量在文件外部使用
  • 10. 使用const可以让引用类型与引用对象的类型不一致
  • 11. 指向常量的指针与常量指针
  • 12. 常量表达式与constexpr
  • 13. 字面值类型和指针constexpr
  • • 字面值类型
    • 指针constexpr
  • 14. decltype与引用
• 第三章 字符串、向量和数组
• • 1. getline函数回车问题
  • 2. 注意c++的字符串字面量的类型
  • 3. 使用size()的注意事项
  • 4. 类模版
  • 5. 来自vector列表初始化的恶意
  • 6. c++的vector与go的slice初始化效率择优方式的不同
  • 7. c++的!=编程规范
  • 8. vector的使用注意事项
  • 9. 兼容c的数组特性
  • 10. 数组的指针与引用：从内向外阅读
  • 11. 范围for语句（for range）中想要改变变量值的注意点
• 第四章 表达式
• • 1. 求值顺序中的未定义表达式
• 第五章 语句
• • 1. c++与go的switch case区别
• 第六章 函数
• • 1. 行参与实参的注意点
  • 2. 函数的指针传参与传引用参数
  • 3. 函数一次返回多个值
  • 4. 数组作为函数参数传递注意事项（p193）
  • 5. 禁止返回局部变量的引用（p201）
  • 6. const_cast强制转换在重载中的广泛使用
• 第七章 类
• • 1. 常量成员函数的来龙去脉
  • 2. 类中函数成员与参数同名情况分析
  • 3. 使用默认初始化初始化一个对象而非声明一个函数(p263)

参考：

• 《C++ Primer》

第一章 开始

1. c++之与其他语言的优点？

风格的灵活性：

• c++较大的特性在于并非像其他语言提供过分的抽象能力，可以完成c风格的底层编程和效率
• c++同时又具备了其他高级语言的抽象功能，能够实现面向对象的编程
• c++的编程风格包括：
  • c风格
  • 基于对象
  • 面向对象
  • 泛型

2. c++语言的组成

• 低级语言：大部分继承自c
• 现代高级语言特性：允许我们自定义类型和大规模程序/系统
• 标准库：用现代高级语言提供的一些高效的数据结构和算法

3. 标准输入输出cin、cout

• cin和cout的多个对象使用<<链接时，即使这些对象不是同一个类型，标准库也会进行处理

  • std::cout << "The sum of " << v1 << " and " << v2 << " is " << v1+v2 << std::endl;

• 如果需要持久的读取多个输入，那么可以配合while循环读取，循环结束的条件是：1.读取到文件结束符EOF 2.一个无效的输入(例如与对象类型不同)

  while (std::cin >> val) {sum += val;
  }    
  

4. include格式

• <>：来自标准库的头文件
• “”：不属于标准库的头文件，则使用双引号包围

第二章 变量和基本类型

1. 无符号数的使用注意

• 当赋值给一个无符号类型的变量一个超出其范围的值的时候，其值为其数值总数的取模的余数

  • 例如：8比特大小的unsigned char可以表示0～255区间，如果赋值了一个区间以外的值，例如赋值-1，那么所得的结果是255

    #include 
    #include int main() {// 无符号整型导致错误(死循环)，-1会被取模为4294967295for (unsigned i=10; i>=0; --i) {std::cout << i << std::endl;sleep(1);}return 0;
    }
    

    

  • 所以不要赋值一个超出无符号数范围的值

  • 不要混用带符号类型和无符号类型，因为带符号整型可能会出现负数导致异常（带符号整型会自动转换为无符号整型）

2. 初始化注意事项

• 最好使用{}的方式初始化变量，这样的好处在于可以在编译期检查是否发生了精度损失

  #include int main() {long double ld = 3.1415926536;int a{ld}, b = {ld};					// 编译错误，{}会检测是否有精度丢失int c(ld), d = ld;						// 正确的，转换发生了会丢失精度	return 0;
  }
  

  

3. 声明与定义

变量的声明与定义的区别：

• 相同点：都规定了变量的类型与名字
• 不同点：定义除了规定还会为变量申请存储空间，也可能给变量赋上一个初始值
• 如果想只声明而不是定义，那么可以使用extern关键字，而且不会显式的初始化变量（如果使用extern的同时赋值，那么就也还是定义）

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

注意点：

• 不能在函数体内部使用extern变量并初始化赋值，这样会报错：

  #include int main() {extern int idx = 3;				// 错误return 0;
  }
  

  

  正确的写法：

  #include extern int idx = 3;int main() {    return 0;
  }
  

作用：

• 如果想在多个文件中使用同一个变量，那么就必须将声明和定义分离开来
  • 因为一个变量只能定义一次（分配一次内存），可以声明多次
  • 在多个文件同时编译的情况下，一个变量有且只能在一个文件中定义，而其他用到的文件可以对其声明，却绝对不能重复定义

4. 标识符的下划线规则

c++不允许：

• 连续出现两个下划线
• 不能以下划线+大写字母开头
• 函数体外的标志符不能用下划线开头

5. &引用、取地址&、指针的区别

https://m.xp.cn/b.php/53505.html

引用：

• c++中出现在变量声明中位于变量左侧的&，表示声明的是对象的引用，其作用就是给等式右边的变量起一个别名，两者是绑定在一起的

  • 引用的右侧必须是一个对象/变量，不能是一个表达式计算结果或字面值
  • 并且被引用的对象必须与引用是相同的数据类型（一般情况下，也有两个特例（[10. 使用const可以让引用类型与引用对象的类型不一致](##10. 使用const可以让引用类型与引用对象的类型不一致)））

• 引用声明的过程中必须要初始化，程序会将引用和它的初始值绑定在一起而不是拷贝初始值到引用（也就是使用被引用对象的同一块内存）

  #include int main() {int a = 10;int &b = a;                                     // b引用a，也就是重命名std::cout << a << ", " << b << std::endl;       // 10, 10b = 20;																					// b修改值std::cout << a << ", " << b << std::endl;       // 20, 20return 0;
  }
  

取地址：

• c++中位于赋值语句右侧的变量的前面&，表示取变量的地址

  int a=3；
  int &b=a；    //引用
  int *p=&a;    //取地址
  

指针：

• c++中使用*表示一个指针对象，指针保存了一个对象的地址，是对该对象的一种间接引用（指针和引用都是对一个对象的间接引用），其本身就是一个对象

• 一个引用只能初始化绑定到一个对象上，之后不能修改，而指针保存的是地址，本身也是一个对象，可以修改地址指向不同的对象

• 指针在声明的时候也不需要必须初始化赋值

• 因为引用没有实际的对象，所以不能定义指向引用的指针

6. 如何理解“因为引用不是对象，没有实际地址，所以不能定义指向引用的指针”

https://blog.csdn.net/fatfish_/article/details/86768887

如下是否就是一个指向引用的指针呢？

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

上述代码编译运行都不会有问题，但是不是如题所示的指向引用的指针，因为引用b就是a，实际上对b取地址&b就等价于&a, 因为引用b是没有地址的

如下可以实现初始化一个指针指向引用（当然是不合理的）：

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

&*c 从右往左读，*表示c是一个指针，&表示c指针指向类型的类型（指向一个引用类型）

7. 复合类型的声明

指针*与引用&都是复合类型，在定义的时候要注意一定要注意其类型修饰符是紧跟变量的，而不要与基本类型放在一起产生误导：

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

8. 指向指针的引用

开始绕。。。

• 引用本身不是一个对象，所以不能定义指向引用的指针

• 但是指针本身是一个新的对象，所以可以创建指向指针的引用

  #include 
  using namespace std;int main() {int i = 42;int *p;int *&r = p;        // r是一个指向p指针的引用r = &i;             // r就是指针p，这一步操作就是将i的地址给p也就是让p指向icout << *p << endl; // 42cout << *r << endl; // 42*r = 0;cout << *p << endl; // 0cout << *r << endl; // 0return 0;
  }
  

一个变量的定义中有多个类型描述符的理解思路：

• 从右向左阅读定义，例如上面的int *&r = p, 首先是&表明r是一个引用，随后*表明r引用的类型是一个指针，最后基本数据类型int表示其是一个指向int类型的指针的引用

9. extern+const让常量在文件外部使用

直接看代码吧:

file_1.cc

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

file_1.h

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

10. 使用const可以让引用类型与引用对象的类型不一致

#include 
using namespace std;int main() {double dval = 3.14;const int &ri = dval;       // 使用int的引用去指向一个double，借助constcout << ri << endl;					// 3ri = 4;                     // 编译报错，ri是一个const不可修改return 0;
}

能完成上面的过程的原因在于，其实是发生了如下的过程(编译器帮我们做了)：

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

引用一个对象就是为了修改，但是const又不能修改，并且能修改也是中间变量，所以这样的做法没有任何的意义

11. 指向常量的指针与常量指针

指向常量的指针，顾名思义就是被指向的对象是一个常量，自己本身也必须是能够指向一个常量类型的指针：

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

常量指针则不同，其关键点在于类似于常量，定义时必须初始化，之后不能再改变（即指针保存的地址是一个常量）

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

从右往左理解：const保证curErr对象本身就是一个常量，*表示其是一个指针

这两个的区别点核心在于：

• 指向常量的指针：强调不变的是指向对象（即指向的对象是const）
• 常量指针：指针自己保存的地址值是一个常量（不会改变）

终极形态：

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

顶层const：指针本身是一个常量

底层const：指针指向的对象是一个常量

=> 指针类型就是一个既可以是顶层const也可以是底层const的类型

当进行拷贝的时候，拷入和拷出的两个对象都应该有相同的底层const资格，否则不被允许

12. 常量表达式与constexpr

什么是常量表达式？

=> 在编译阶段就可以知道其具体结果的表达式

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

如果不是常量表达式，那么在运行期和编译期变量的定义与使用完全是不同的，所以我们需要确切的限制，让常量的赋值是一个常量表达式

在大型项目中，难以一眼看出，所以c++的编译器可以帮我们做这一步的判断，也就是使用constexpr

#include 
using namespace std;int main() {constexpr int mf = 20;constexpr int limit = mf+10;     constexpr int sz = size();      // size函数必须是一个constexpr函数
}

13. 字面值类型和指针constexpr

字面值类型

因为constexpr要在编译期间就能计算到，所以就要限制其用到的类型，这些类型比较简单显而易见，所以叫“字面值类型”

算术类型、引用、指针都是字面值类型

但是指针的字面值类型需要特别注意的是：必须初始化为nullptr或者0或者一个固定地址中的对象（地址在堆中而不是在栈中，即应该是全局变量的地址而不是一个局部变量的地址）

指针constexpr

constexpr限定指针是一个常量指针：

#include 
using namespace std;int main() {const int *p = nullptr;             // 指向常量的指针constexpr int *p2 = nullptr;        // 常量指针constexpr const int *p3 = nullptr;  // 指向常量的常量指针
}

constexpr可以将其对象设置为顶层const

14. decltype与引用

decltype用于推断对象的类型而不需要执行、初始化该变量

有几个特殊的点：

• 获取引用的类型的时候，得到的结果不是引用对象的类型，而是引用：

  const int ci = 0, &cj = ci;
  decltype(cj) x;			// 错误，decltype(cj)返回的是const int&，而不是const int，所以必须要初始化
  

  这里也是唯一一个引用作为原对象的同义词的一个例外

• decltype对指针的解引用的结果不是指针指向的对象的类型而是其引用类型

  int i = 42, *p = &i;
  decltype(*p) c;			// 错误，decltype(*p)返回的类型结果是int&即是对int的引用，所以必须要初始化
  

• 如果给变量加上括号，也会变成引用

  decltype((i)) d; 		// 错误，d的类型是int&，要初始化
  decltype(i) e; 			// 正确，e是一个未初始化的int
  

总结来说，decltype处理复合类型（引用、指针）的间接引用的时候，不会解析到最终的引用对象而是引用类型本身

第三章 字符串、向量和数组

1. getline函数回车问题

getline(cin, s)函数会读取一行字符串直到回车，本身会读取掉回车，但是赋值给s的时候不会赋值回车（回车被丢弃了）

2. 注意c++的字符串字面量的类型

c++中字符串字面量的类型不是string（为了兼容c），不是不能直接使用两个字符串字面量+运算（必须有一个是string类型才可）

3. 使用size()的注意事项

字符串函数size()返回字符串的大小，但是返回的类型是string::size_type是一个无符号整型，如果和一个有符号数一起使用，那么就可能会出现问题：

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

#include 
#include 
using namespace std;int main() {string s;cin >> s;for (int i=0; i

vector ivec;

#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;
}

#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;
}

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

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数组的引用
}

#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;}
}

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

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

#include 
using namespace std;int main() {int i = 0;cout << i << " " << ++i << endl;			// i的运算顺序未知，所以这样编写的代码也是无意义的return 0;
}

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

#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;      // 0i = 42;reset2(i);cout << i << endl;      // 0return 0;
}

#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;
}

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

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

#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;
}

#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 abcout << shortString(s3, s4) << endl;        // call const shortString efreturn 0;
}

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

typedef int pos;
pos height;                 // 最外层的height
class dummy
{
private:/* data */
public:pos cursor, width, height;           // 成员heightvoid dummy_fcn(pos height) {         // 参数heightcursor = height * width;        // 这个height是那个height?}
};

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

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

Sale_data obj();		// 创建了一个返回类似是Sale_data的空参数函数声明
obj.isbn();					// 将会报错，因为obj是一个函数而不是一个对象			// 正确的写法（使用默认初始化）：
Sale_data obj;