c++难点&核心笔记(一)

---

前言

C++在TIOBE上的流行指数一度逼近18%，可谓如日中天，所以毫无悬念，C++重夺年度语言…
目标：这系列文章会记录一下，编码风格，常见错误，如何调试，好的编程实战，如何测试等学习内容

---

C++的应用领域

1. 服务器端开发：很多游戏或者互联网公司的后台服务器程序都是基于C++开发的，而且大部分是linux操作系统
2. 嵌入式开发：嵌入式相关的岗位需求比较多，主要是硬件产品的驱动开发，很多大公司，比如华为、小米、vivo和一些芯片公司都在大量的招聘嵌入式开发工程师.
3. 游戏 ：以腾讯微代表的游戏公司，很多游戏都是C++开发的.
4. 人工智能：深度学习工程化开发。人工智能目前可以落地的主要领域，是安防和自动驾驶，这块都会使用C++开发，包括深度学习算法SDK，深度学习框架开发等。
5. 数字图像处理：比如像AutoCAD的系统开发，像OpenCV的视觉识别等等。
   软件开发，通常遵循如下流程：
   

---

核心编程

内存分区模型

程序在执行时，将内存大方向划分为4个区域：

• 代码区：存放函数体的二进制代码，由操作系统进行管理
• 全局区：存放全局变量和静态变量以及常量
• 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
• 堆区：由程序员分配和释放，如果程序员不释放，程序结束时由操作系统回收

不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程

1.程序运行前

未执行该程序前分为两个区域

• 代码区：
  1️⃣存放 CPU 执行的机器指令。
  2️⃣代码区是共享的，共享的目标是对于频繁被执行的程序，只需要在内存中有一份代码即可。
  3️⃣代码区是只读的。使其只读的原因是防止程序意外地修改了它的指令。

• 全局区：
  1️⃣全局变量和静态变量存放在此。
  2️⃣ 全局区包含常量区，字符串常量和其他常量存放
  3️⃣该区域的数据在程序结束后由操作系统释放

 //全局变量
int g_a = 10;
int g_b = 10;
//全局常量
const int c_g_a = 10;
const int c_g_b = 10;
int main() {
   
   
	//局部变量
	int a = 10;
	int b = 10;
	//打印地址
	cout << "局部变量a地址为： " << (int)&a << endl;
	cout << "局部变量b地址为： " << (int)&b << endl;
	cout << "全局变量g_a地址为： " <<  (int)&g_a << endl;
	cout << "全局变量g_b地址为： " <<  (int)&g_b << endl;
    //静态变量
	static int s_a = 10;
	static int s_b = 10;
cout << "静态变量s_a地址为： " << (int)&s_a << endl;
	cout << "静态变量s_b地址为： " << (int)&s_b << endl;
	cout << "字符串常量地址为： " << (int)&"hello world" << endl;
	cout << "字符串常量地址为： " << (int)&"hello world1" << endl;
	cout << "全局常量c_g_a地址为： " << (int)&c_g_a << endl;
	cout << "全局常量c_g_b地址为： " << (int)&c_g_b << endl;
	const int c_l_a = 10;
	const int c_l_b = 10;
	cout << "局部常量c_l_a地址为： " << (int)&c_l_a << endl;
	cout << "局部常量c_l_b地址为： " << (int)&c_l_b << endl;
	system("pause");
	return 0;
}

2.程序运行后

• 栈区：

  由编译器自动分配释放, 存放函数的参数值,局部变量等
  不会返回局部变量的地址，栈区开辟的数据由编译其自动释放

int * func()
{
   
   
	int a =10;
	return &a;
}

• 堆区：

​ 由程序员分配释放,若程序员不释放,程序结束时由操作系统回收，在C++中主要利用new在堆区开辟内存

3.new操作符

​ C++中利用new操作符在堆区开辟数据
​ 堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符 delete

​ 语法： new 数据类型
​ 利用new创建的数据，会返回该数据对应的类型的指针

int* func()
{
   
   
	int* a = new int(10);
	return a;
}

int main() {
   
   

	int *p = func();
	cout << *p << endl;
	cout << *p << endl;
	//利用delete释放堆区数据
	delete p;
	//cout << *p << endl; //报错，释放的空间不可访问
	system("pause");

	return 0;
}

示例2：开辟数组

//堆区开辟数组
int main() {
   
   

	int* arr = new int[10];
	for (int i = 0; i < 10; i++)
	{
   
   
		arr[i] = i + 100;
	}
	for (int i = 0; i < 10; i++)
	{
   
   
		cout << arr[i] << endl;
	}
	//释放数组 delete 后加 []
	delete[] arr;
	system("pause");
	return 0;
} 

引用

作用：给变量起别名

语法： 数据类型 &别名 = 原名

• 引用必须初始化
• 引用在初始化后，不可以改变

int main() {
   
   

	int a = 10;
	int b = 20;
	//int &c; //错误，引用必须初始化
	int &c = a; //一旦初始化后，就不可以更改
	c = b; //这是赋值操作，不是更改引用

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	system("pause");

	return 0;
}

• 引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

//1. 值传递
void mySwap01(int a, int b) {
   
   
	int temp = a;
	a = b;
	b = temp;
}

//2. 地址传递
void mySwap02(int* a, int* b) {
   
   
	int temp = *a;
	*a = *b;
	*b = temp;
}

//3. 引用传递
void mySwap03(int& a, int& b) {
   
   
	int temp = a;
	a = b;
	b = temp;
}

int main() {
   
   

	int a = 10;
	int b = 20;

	mySwap01(a, b);
	cout << "a:" << a << " b:" << b << endl;

	mySwap02(&a, &b);
	cout << "a:" << a << " b:" << b << endl;

	mySwap03(a, b);
	cout << "a:" << a << " b:" << b << endl;

	system("pause");

	return 0;
}

总结：通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单

• 引用做函数返回值

作用：引用是可以作为函数的返回值存在的

注意：不要返回局部变量引用

用法：函数调用作为左值

//返回局部变量引用
int& test01() {
   
   
	int a = 10; //局部变量
	return a;
}
//返回静态变量引用
int& test02() {
   
   
	static int a = 20;
	return a;
}
int main() {
   
   

	//不能返回局部变量的引用
	int& ref = test01();
	cout << "ref = " << ref << endl;
	cout << "ref = " << ref << endl;

	//如果函数做左值，那么必须返回引用
	int& ref2 = test02();
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	test02() = 1000;

	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	system("pause");

	return 0;
}

• 引用的本质

本质：引用的本质在c++内部实现是一个指针常量.

//发现是引用，转换为 int* const ref = &a;
void func(int& ref){
   
   
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
   
   
	int a = 10;
    
    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a; 
	ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
    
	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;
    
	func(a);
	return 0;
}

• 常量引用
  作用：常量引用主要用来修饰形参，防止误操作
  在函数形参列表中，可以加const修饰形参，防止形参改变实参

//引用使用的场景，通常用来修饰形参
void showValue(const int& v) {
   
   
	//v += 10;
	cout << v << endl;
}

int main() {
   
   

	//int& ref = 10;  引用本身需要一个合法的内存空间，因此这行错误
	//加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
	const int& ref = 10;

	//ref = 100;  //加入const后不可以修改变量
	cout << ref << endl;

	//函数中利用常量引用防止误操作修改实参
	int a = 10;
	showValue(a);
	system("pause");
	return 0;
}

函数

函数让您能够划分和组织程序的执行逻辑。通过使用函数，可将应用程序的内容划分成依次调用的逻辑块。

函数是子程序，可接受参数并返回值，要让函数执行其任务，必须调用它。

• 为何需要编写函数；
• 函数原型和函数定义；
• 给函数传递参数以及从函数返回值；
• 重载函数；
• 递归函数；
• C++11 lambda 函数。

1.概述和函数原型

作用：将一段经常使用的代码封装起来，减少重复代码
一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

cout << "Area is: " << Area(radius) << endl;
cout << "Circumference is: " << Circumference(radius) << endl;

函数原型：就是指出函数的名称（Area）、函数接收的参数列表（double radius）以及返回值的类型（double）

函数原型告诉编译器，Area 和 Circumference 是函数，它们接受一个类型为 double 的参数，并返回一个类型为 double 的值

2.函数的定义和参数

函数的定义一般主要有5个步骤：
1、返回值类型
2、函数名
3、参数表列
4、函数体语句
5、return 表达式

语法：

返回值类型 函数名 （参数列表）
{
   
    
       函数体语句 
       return表达式 
}  

• 返回值类型 ：一个函数可以返回一个值。在函数