C++: 一文梳理c++核心编程基础知识点

之前c++面试总是觉得被面试官碾压，所以痛定思痛好好总结一把c++

1.内存分区模型

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

-代码区：存放函数体的二进制代码，由操作系统进行管理的

-全局区：存放全局变量和静态变量以及常量

-栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等

• 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

** 内存四区意义：** 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程

程序运行前

在程序编译后，生成了exe可执行程序，

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

代码区：  

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

全局区：

• 全局变量和静态变量存放在此. ​
• 全局区还包含了常量区, 字符串常量和其他常量也存放在此. ​  
• 该区域的数据在程序结束后由操作系统释放. 

**总结： **

• C++中在程序运行前分为全局区和代码区 
• 代码区特点是共享和只读
• 全局区中存放全局变量、静态变量、常量 * 常量区中存放 const修饰的全局常量和字符串常量 

程序运行后

栈区：

由编译器自动分配释放, 存放函数的参数值,局部变量等 ​

注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放 

堆区：

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

总结:

• 堆区数据由程序员管理开辟和释放
• 堆区数据利用new关键字进行开辟内存

new操作符

C++中利用new操作符在堆区开辟数据 ​ 堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符 delete ​ 语法： new 数据类型 ​ 利用new创建的数据，会返回该数据对应的类型的指针 

**高频考点：**new和malloc使用规则和区别

C语言提供了malloc和free两个系统函数，完成对堆内存的申请和释放。而C++则提供了两个关键字new和delete；

使用规则：

• new/delete是关键字，效率高于malloc和free。
• 配对使用，避免内存泄漏和多重释放。
• 避免交叉使用，比如malloc申请空间delete释放，new出的空间被free。
• new/delete 主要是用在类对象的申请和释放。申请的时候会调用构造器完成初始化，释放的时候，会调用析构器完成内存清理。

区别：

• 属性

new和delete是C++关键字，需要编译器支持；malloc和free是库函数，需要头文件支持。

• 参数

使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。

• 返回类型

new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

• 自定义类型

new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。

malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。

• “重载”

C++允许自定义operator new 和 operator delete 函数控制动态内存的分配。

• 内存区域

new做两件事：分配内存和调用类的构造函数，delete是：调用类的析构函数和释放内存。而malloc和free只是分配和释放内存。

new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区不等于堆，如上所述，布局new就可以不位于堆中。

• 分配失败

new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时返回NULL。

• ** 内存泄漏**

内存泄漏对于new和malloc都能检测出来，而new可以指明是哪个文件的哪一行，malloc确不可以。

2.引用

引用的基本使用：

• 作用：给变量起别名
• 语法：数据类型 &别名 = 原名 

注意事项：

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

引用做函数参数

• 作用：函数传参时，可以利用引用的技术让形参修饰实参
• 优点：可以简化指针修改实参，通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单

引用做函数返回值

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

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

用法：函数调用作为左值

//返回局部变量引用
int& test1() {
	int a = 10; //局部变量
	return a;
}

//返回静态变量引用
int& test2() {
	static int a = 20;
	return a;
}

int main() {

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

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

	test2() = 10;

	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;

	system("pause");

	return 0;
}

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

常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

3.函数重载

作用：函数名可以相同，提高复用性 

函数重载满足条件：

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同或者个数不同或者顺序不同

注意: 函数的返回值不可以作为函数重载的条件

特殊例子

• 引用作为重载条件

• 函数重载碰到函数默认参数

  //函数重载注意事项 //1、引用作为重载条件

  void func(int &a) { cout << "func (int &a) 调用 " << endl; }

  void func(const int &a) { cout << "func (const int &a) 调用 " << endl; }

  //2、函数重载碰到函数默认参数

  void func2(int a, int b = 10) { cout << "func2(int a, int b = 10) 调用" << endl; }

  void func2(int a) { cout << "func2(int a) 调用" << endl; }

  int main() {

  int a = 10;
  func(a); //调用无const
  func(10);//调用有const
  
  //func2(10); //碰到默认参数产生歧义，需要避免
  
  system("pause");
  
  return 0;
  

  }

4.类和对象

C++面向对象的三大特性为：封装、继承、多态

封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

类在设计时，可以把属性和行为放在不同的权限下，加以控制 

访问权限有三种： 

• public 公共权限  类内可以访问 类外可以访问
• protected 保护权限 类内可以访问 类外不可以访问
• private 私有权限 类内可以访问 类外不可以访问

Q&A struct和class的区别

在C++中 struct和class唯一的区别就在于默认的访问权限不同区别：

• struct 默认权限为公共 
• class 默认权限为私有

成员属性设置为私有

• 优点1：将所有成员属性设置为私有，可以自己控制读写权限
• 优点2：对于写权限，我们可以检测数据的有效性

构造函数和析构函数

构造函数

• 构造函数，没有返回值也不写void 
• 函数名称与类名相同 
• 构造函数可以有参数，因此可以发生重载 
• 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数

• 析构函数，没有返回值也不写void 
• 函数名称与类名相同,在名称前加上符号 ~ 
• 析构函数不可以有参数，因此不可以发生重载 
• 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

构造函数的分类及调用

两种分类方式：

• 按参数分为： 有参构造和无参构造 ​
• 按类型分为： 普通构造和拷贝构造 

 三种调用方式： ​

• 括号法 ​

• 显示法 ​

• 隐式转换法

  class Person { public: //无参（默认）构造函数 Person() { cout << "无参构造函数!" << endl; } //有参构造函数 Person(int a) { age = a; cout << "有参构造函数!" << endl; } //拷贝构造函数 Person(const Person& p) { age = p.age; cout << "拷贝构造函数!" << endl; } //析构函数 ~Person() { cout << "析构函数!" << endl; } public: int age; };

调用例子：

//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

拷贝构造函数的调用时机

C++中拷贝构造函数调用时机通常有三种情况

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数 

1．默认构造函数(无参，函数体为空) 

 2．默认析构函数(无参，函数体为空) 

 3．默认拷贝构造函数，对属性进行值拷贝 构造函数调用规则如下：  

如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造 

如果用户定义拷贝构造函数，c++不会再提供其他构造函数

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作 

深拷贝：在堆区重新申请空间，进行拷贝操作

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {

		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);//构造函数在堆区新建了一块内存

	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);

	}

	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);

	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;

	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

类对象作为类成员

c++类中的额成员可以是另一个类的对象，我们称该成员为对象成员。

class A{}
class B{
A a;
}

Q&A

B类中有对象A作为成员，A为对象成员, 那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

构造的顺序是 ：先调用对象成员的构造，再调用本类构造（先A后B） 

析构顺序与构造相反（先B后A）

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员 

静态成员分为： 

静态成员变量：

• 所有对象共享同一份数据
• 在编译阶段分配内存
• 类内声明，类外初始化

静态成员函数：

• 所有对象共享同一个函数
• 静态成员函数只能访问静态成员变量

C++对象模型和this指针

成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

this指针概念

Q&A 每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码 那么问题是：这一块代码是如何区分那个对象调用自己的呢？

c++通过提供特殊的对象指针，this指针，解决上述问题。

this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针 this指针不需要定义，直接使用即可 this指针的用途:

• 当形参和成员变量同名时，可用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this

空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性 

const修饰成员函数

常函数：

• 成员函数后加const后我们称为这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改

 常对象：

• 声明对象前加const称该对象为常对象

• 常对象只能调用常函数 

  class Person { public: Person() { m_A = 0; m_B = 0; }

  //this指针的本质是一个指针常量，指针的指向不可修改
  //如果想让指针指向的值也不可以修改，需要声明常函数
  void ShowPerson() const {
  	//const Type* const pointer;
  	//this = NULL; //不能修改指针的指向 Person* const this;
  	//this->mA = 100; //但是this指针指向的对象的数据是可以修改的
  
  	//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
  	this->m_B = 100;
  }
  
  void MyFunc() const {
  	//mA = 10000;
  }
  

  public: int m_A; mutable int m_B; //可修改 可变的 };

  //const修饰对象 常对象 void test01() {

  const Person person; //常量对象  
  cout << person.m_A << endl;
  //person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
  person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
  
  //常对象访问成员函数
  person.MyFunc(); //常对象不能调用const的函数
  

  }

  int main() {

  test01();
  
  system("pause");
  
  return 0;
  

  }

友元

友元的目的就是让一个函数或者类 访问另一个类中私有成员 

 友元的关键字为friend

友元的三种实现:

• 全局函数做友元
• 类做友元
• 成员函数做友元

继承

继承的基本语法

class A : public B;

A类称为子类或派生类

B类称为父类或基类

派生类中的成员，包含两大部分： 

 一类是从基类继承过来的，一类是自己增加的成员。 从基类继承过过来的表现其共性，而新增的成员体现了其个性。

继承方式：

• 公共继承

• 保护继承

• 私有继承

  class Base1 { public: int m_A; protected: int m_B; private: int m_C; };

  //公共继承 class Son1 :public Base1 { public: void func() { m_A; //可访问 public权限 m_B; //可访问 protected权限 //m_C; //不可访问 } };

  void myClass() { Son1 s1; s1.m_A; //其他类只能访问到公共权限 }

  //保护继承 class Base2 { public: int m_A; protected: int m_B; private: int m_C; }; class Son2:protected Base2 { public: void func() { m_A; //可访问 protected权限 m_B; //可访问 protected权限 //m_C; //不可访问 } }; void myClass2() { Son2 s; //s.m_A; //不可访问 }

  //私有继承 class Base3 { public: int m_A; protected: int m_B; private: int m_C; }; class Son3:private Base3 { public: void func() { m_A; //可访问 private权限 m_B; //可访问 private权限 //m_C; //不可访问 } }; class GrandSon3 :public Son3 { public: void func() { //Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到 //m_A; //m_B; //m_C; } };

继承中的对象模型

 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

结论：继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

答案：访问子类同名成员 直接访问即可，访问父类同名成员 需要加作用域

总结：  

• 子类对象可以直接访问到子类中同名成员 
• 子类对象加作用域可以访问到父类同名成员 
• 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

答案：静态成员和非静态成员出现同名，处理方式一致 

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域 

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

问题：菱形继承

1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。 2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。 

 总结： * 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义 * 利用虚继承可以解决菱形继承问题

4.多态

多态分为两类：

静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名

动态多态: 派生类和虚函数实现运行时多态 

静态多态和动态多态区别：静态多态的函数地址早绑定 - 编译阶段确定函数地址

动态多态的函数地址晚绑定 - 运行阶段确定函数地址

多态满足条件：

有继承关系

子类重写父类中的虚函数

多态使用：

父类指针或引用指向子类对象

纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;

抽象类特点： 

• 无法实例化对象  
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性： 

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现 

虚析构和纯虚析构区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象 

总结： ​

• 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象 ​
• 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构 ​
• 拥有纯虚析构函数的类也属于抽象类