蒟蒻猫

黑马程序员——C++笔记

习题

习题描述

问题集

新手村：

cout << "a = " << a << endl;
标识符第一个字符必须为字母或下划线
cout << (int)ch << endl; //查看字符a对应的ASCII码
sizeof( 数据类型 / 变量)
float f1 = 3.14f;//注意这里加了个f 这样加的好处是之后不用再进行转换，一步到位
//ch = “abcde”; //错误，不可以用双引号
//ch = ‘abcde’; //错误，单引号内只能引用一个字符
作用：用于表示一些不能显示出来的ASCII字符 \n \ \t
C++风格字符串： string 变量名 = “字符串值”
bool类型占1个字节大小
C++风格字符串，需要加入头文件==#include==
语法： cin >> 变量
Int型除法不保留小数
与&& 或||
表达式1 ? 表达式2 ：表达式3
如果表达式1的值为真，执行表达式2，并返回表达式2的结果；
如果表达式1的值为假，执行表达式3，并返回表达式3的结果。
与while循环区别在于，do…while先执行一次循环语句，再判断循环条件
break使用的时机：
出现在switch条件语句中，作用是终止case并跳出switch
出现在循环语句中，作用是跳出当前的循环语句
出现在嵌套循环中，跳出最近的内层循环语句
continue语句
作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
如果{}内不足10个数据，剩余数据用0补全
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
数组名用途
- 可以获取整个数组占用内存空间大小
  cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
  cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
- 可以通过数组名获取到数组首地址
  cout << "数组首地址为： " << (int)arr << endl;
  cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl; //int作用是调整为十进制类型，本来是十六进制类型
  cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl; //&符号的作用是获取变量地址
- 数组名是常量，不可以赋值
同理二维数组
值传递时，==如果形参发生，并不会影响实参
函数的声明可以多次，但是函数的定义只能有一次
函数分文件编写一般有4个步骤
创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义
#include “swap.h”
指针
普通变量存放的是数据,指针变量存放的是地址
指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用
空指针指向的内存是不可以访问的
野指针：指针变量指向非法的内存空间
所有指针类型在32位操作系统下是4个字节
因为存的是地址
32位指一次能处理32为数据，一般来讲，处理位数和地址总线和数据总线位数会做一致，方便操作
故32位的地址是4个字节
指针
常量指针
//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
const int * p1 = &a;
指针常量
int * const p2 = &a;
//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
即修饰指针又修饰常量
const int * const p3 = &a;
指针遍历数组cout << *p << endl; p++;
地址传递
void swap2(int * p1, int *p2)
swap2(&a, &b); //地址传递会改变实参
结构体结构体数组
指针访问结构体是通过 -> 操作符可以访问成员
int * arr 也可以写为int arr[] 当数组名传入到函数作为参数时，被退化为指向首元素的指针
add->man[add->flag ].m_name =name;//这里出错了，前面用->后面用.
system(“cls”);//清屏函数

核心编程：

内存分区模型

意义

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

程序执行时

代码区：存放函数体的二进制代码，由操作系统进行管理的
全局区：存放全局变量和静态变量以及常量
栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等
不要返回局部变量的地址，栈区开辟的数据由编译器自动释放
第二次是这个数值不在保留，所以不要返回局部变量地址
堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

int* func()
{
    //指针本质是局部变量，放在栈上，指针保存的数据是放在堆区
	int* a = new int(10);
	return a;
}
int main() {

	int *p = func();
	//数组写法
	int* arr = new int[10];
	
	cout << *p << endl;
	cout << *p << endl;
    delete p;
    //释放数组 delete 后加 []
	delete[] arr;
	
	return 0;
}

程序运行前

代码区：
存放 CPU 执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量存放在此.
全局区还包含了常量区, 字符串常量和其他常量也存放在此.
该区域的数据在程序结束后由操作系统释放

引用

意义

给变量起别名
引用的本质是指针常量,但是所有的指针操作编译器都帮我们做了
函数传参时，可以简化指针修改实参。

注意事项

引用必须初始化，初始化后不能更改
引用做函数参数
引用做函数返回值不要返回局部变量的引用函数调用可作为左值

//返回静态变量引用
int& test02() {
	static int a = 20;
	return a;
}
int main(){
	//如果函数做左值，那么必须返回引用
	int& ref2 = test02();
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	test02() = 1000;
	cout << "ref2 = " << ref2 << endl;
}

常量引用

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

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

函数提高

默认参数

函数的形参列表中的形参是可以有默认值的
如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
函数声明和实现只能有一个默认参数

//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b) {
	return a + b;
}

函数重载

就是可以用同一个函数名

条件

同一个作用域下
函数名称相同
函数参数类型不同或者个数不同或者顺序不同
函数的返回值不可以作为函数重载的条件

类

封装

三种权限

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

struct和class的区别

在C++中 struct和class唯一的区别就在于 默认的访问权限不同
struct 默认权限为公共
class 默认权限为私有

成员属性设置为私有

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

对象的初始化和清理

构造函数和析构函数

默认情况下，c++编译器至少给一个类添加3个函数
默认构造函数(无参，函数体为空)
默认析构函数(无参，函数体为空)
默认拷贝构造函数，对属性进行值拷贝
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

语法

class Person
{
public:
	//构造函数
/*
1. 构造函数，没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
*/
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	
	//析构函数
/*
6. 析构函数，没有返回值也不写void
7. 函数名称与类名相同,在名称前加上符号  ~
8. 析构函数不可以有参数，因此不可以发生重载
9. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
*/
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

构造函数的分类及调用

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

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

//2、构造函数的调用
//调用无参构造函数
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;
}

拷贝构造函数调用时机

三种方式

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

class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person man(100); //p对象已经创建完毕
	Person newman(man); //调用拷贝构造函数
	Person newman2 = man; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
	Person p; //无参构造函数
	doWork(p);
}

//3. 以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int *)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();
	cout << (int *)&p << endl;
}


int main() {

	//test01();
	//test02();
	test03();

	system("pause");

	return 0;
}

深拷贝与浅拷贝

概念

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题，如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题

简易理解

最简单直接的解释大概就是，浅拷贝实际上是对类成员的引用，深拷贝是对类成员的复制并且重新分配了内存。
所谓拷贝就是平常意义的复制，至于深浅，就因为一个东西：指针拷贝的时候，如果有指针，那么也就是对指针的拷贝，指针怎么拷贝？指针本质也就是一个存储地址的整形，所以拷贝的时候，也就是把指针本身进行复制，这样就导致一个问题：本体与复制体的指针成员实际是一个值（地址值），那么他们会操作同一个地址的内存内容，在析构的时候，就出现问题了，本体或者复制体进行析构的时候，将指针成员kill了，即把指针成员对应的地址内容kill掉了，那么另外一个复制体或者本体的指针成员怎么办？？？？野指针啊！就因为这么个原因，为了让程序猿对这个问题加深认知，就出现了两个名词：深拷贝、浅拷贝！实际并没有什么深拷贝和浅拷贝，出现这两个词的原因也就是为了让你随时记住指针问题！万恶的指针！如果你对指针有着极其深刻的认知，随时能注意指针的动向，那么深拷贝、浅拷贝？忽悠小孩子的啦~
文件创建快捷方式是浅拷贝
文件复制文件是深拷贝
浅拷贝的文件被删除快捷方式失效
深拷贝的源文件被删除，备份文件仍有

初始化列表

class Person {
public:

	传统方式初始化
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

int main() {
	Person p(1, 2, 3);
	p.PrintPerson();
	system("pause");
	return 0;
}

类对象作为类成员

当类中成员是其他类对象时，我们称该成员为对象成员
构造的顺序是：先调用对象成员的构造，再调用本类构造
析构顺序与构造相反

静态成员

概念

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

静态成员分为：

静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量

C++对象模型和this指针

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

空对象所占空间

class Person {
public:
	Person() {
		mA = 0;
	}
	//非静态成员变量占对象空间
	int mA;
	//静态成员变量不占对象空间
	static int mB; 
	//函数也不占对象空间，所有函数共享一个函数实例
	void func() {
		cout << "mA:" << this->mA << endl;
	}
	//静态成员函数也不占对象空间
	static void sfunc() {
	}
};

int main() {
	cout << sizeof(Person) << endl;
	system("pause");
	return 0;
}

this指针概念

本质

this指针的本质是一个指针常量，指针的指向不可修改

用途

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

this指针的用途：

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

空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性

const修饰成员函数

常函数：

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

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数

友元

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

三种实现

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

运算符重载

对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

int a=10,b=10;
int c=a+b;
person p1,p2,p3;
p3=p1+p2;//编译器会不知道如何实现，所以可以定义一个类的
//函数实现加号运算,本质就是调用这个函数，这是编译器简化了这个写法

加号运算符重载

	//成员函数实现 + 号运算符重载
	Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}

//全局函数实现 + 号运算符重载
Person operator+(const Person& p1, const Person& p2) {
	Person temp(0, 0);
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

左移运算符重载

作用：可以输出自定义数据类型

//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

/*
out  cout都没有差，因为引用相当于取别名
cout << p1 << "hello world" << endl; //链式编程
链式编程在于每次返回都是同一个对象，故需要返回输出流
*/

递增运算符重载

/*
返回类型为引用，这样才能进行连续递增操作
注意后置递增的写法
*/

	//前置++
	MyInteger& operator++() {
		//先++
		m_Num++;
		//再返回
		return *this;
	}

	//后置++
	MyInteger operator++(int) {
		//先返回
		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		m_Num++;
		return temp;
	}

赋值运算符重载

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题
所以需要定义赋值运算符

继承

简要

好处：减少重复代码
继承的语法：class 子类 : 继承方式父类

继承方式

继承中的对象模型

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

继承中构造和析构顺序

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

继承同名成员处理方式

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

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

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

菱形继承

数据两份，重复了
利用虚继承可以解决菱形继承问题
其实就是变成指针

多态

基础

多态分为两类

静态多态: 函数重载和运算符重载属于静态多态，复用函数名
动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

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

多态满足条件

有继承关系
子类重写父类中的虚函数

多态使用条件

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

重写：函数返回值类型函数名参数列表完全一致称为重写

虚函数
其实就是变成指针

	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

多态的优点：

代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护

纯虚函数和抽象类

来源

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数

当类中有了纯虚函数，这个类也称为抽象类

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

抽象类特点：

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

虚析构和纯虚析构

问题

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

总结：

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

文件操作

模板

简介

C++另一种编程思想称为泛型编程，主要利用的技术就是模板
C++提供两种模板机制:函数模板和类模板
模板的目的是为了提高复用性，将类型参数化
模板的通用性并不是万能的
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

函数模板

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

//利用模板提供通用的交换函数
template<typename T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

	//利用模板实现交换
	//1、自动类型推导
	mySwap(a, b);

	//2、显示指定类型
	mySwap<int>(a, b);

注意事项：

自动类型推导，必须推导出一致的数据类型T,才可以使用
模板必须要确定出T的数据类型，才可以使用

普通函数与函数模板区别：

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

普通函数与函数模板的调用规则
调用规则如下：

如果函数模板和普通函数都可以实现，优先调用普通函数
可以通过空模板参数列表来强制调用函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配,优先调用函数模板

类模板

STL

STL(Standard Template Library,标准模板库)
STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
容器和算法之间通过迭代器进行无缝连接。
STL 几乎所有的代码都采用了模板类或者模板函数

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
容器就是将运用最广泛的一些数据结构实现出来
分为序列式容器和关联式容器两种
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
算法：各种常用的算法，如sort、find、copy、for_each等
迭代器：扮演了容器与算法之间的胶合剂。
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器
迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针
仿函数：行为类似函数，可作为算法的某种策略。

主要前4个

适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
6. 空间配置器：负责空间的配置与管理。

面试问题

为什么析构函数要用虚函数

https://www.cnblogs.com/howo/p/8531449.html

析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

虚函数：其实就是变成指针

	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

虚析构和纯虚析构

问题

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

void test01()
{
Animal *animal = new Cat(“Tom”);
animal->Speak();

  //通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
  //怎么解决？给基类增加一个虚析构函数
  //虚析构函数就是用来解决通过父类指针释放子类对象
  delete animal;

}

其他延伸

为什么无法调用子类代码

因为之类pB是基类指针，虽然指向的是派生类，只能调用自己的函数，我们是无法通过基类指针调用到子类的成员函数的

多态满足条件

有继承关系
子类重写父类中的虚函数

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

构造函数在创建对象的时候调用，先调用父类，再子类，析构相反

（1）当父类的指针new一个子类的对象时，

父类析构不是虚析构，则delete的时候不调用子类的，只是调用父类的析构函数，如果是virtual的析构函数，则先子类之后父类

（2）当子类的指针new一个子类的对象时，构造析构都会调用父类

c/c++ 堆区程序员分配的内存，不释放，在程序结束时,系统一定会回收内存吗？

程序结束是一定回收的，可以放心。内存溢出是如果你执行很久或者很大的程序，一直在申请不释放。或者比如说一个大项目，你写了一个模块，申请了一块内存不释放，别人调用你的模块调用了几千几万次，内存就溢出了。不过任何操作系统，程序结束了是肯定会回收的。

类中只要有一个纯虚函数就称为抽象类
//抽象类无法实例化对象
//子类必须重写父类中的纯虚函数，否则也属于抽象类

内存泄漏

内存泄漏（Memory Leak）是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题，如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题

所谓拷贝就是平常意义的复制，至于深浅，就因为一个东西：指针拷贝的时候，如果有指针，那么也就是对指针的拷贝，指针怎么拷贝？指针本质也就是一个存储地址的整形，所以拷贝的时候，也就是把指针本身进行复制，这样就导致一个问题：本体与复制体的指针成员实际是一个值（地址值），那么他们会操作同一个地址的内存内容，在析构的时候，就出现问题了，本体或者复制体进行析构的时候，将指针成员kill了，即把指针成员对应的地址内容kill掉了，那么另外一个复制体或者本体的指针成员怎么办？？？？野指针啊！

++i 与i++

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hf60tTzZ-1617283322973)(C:\Users\wangxiaobing\AppData\Roaming\Typora\typora-user-images\image-20210315185239494.png)]

全局变量和局部变量在内存中是否有区别？如果有是什么区别？

.生存周期不同全局变量:全局区（静态区）（static）：全局变量和静态变量是存储在一起的，初始化过的全局变量和静态变量在同一块区域，未初始化的全局变量和静态变量存放在一块相邻的区域内。此区域由系统在程序结束后释放局部变量：放在堆栈中。由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈
作用范围不同全局变量具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包含全局变量定义的源文件需要用extern 关键字再次声明这个全局变量。局部变量也只有局部作用域，它是自动对象（auto），它在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回

引用与指针有什么区别

指针和引用都是地址的概念，指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。程序为指针变量分配内存区域，而不为引用分配内存区域。
引用在定义时就被初始化，之后无法改变；指针可以发生改变。即引用的对象不能改变，指针的对象可以改变。
没有空引用，但有空指针。这使得使用引用的代码效率比使用指针的更高。因为在使用引用之前不需要测试它的合法性。相反，指针则应该总是被测试，防止其为空。
对引用使用“sizeof”得到的是变量的大小，对指针使用“sizeof”得到的是变量的地址的大小。
理论上指针的级数没有限制，但引用只有一级。即不存在引用的引用，但可以有指针的指针。
int **p //合法
int &&p //非法
++引用与++指针的效果不一样。
例如就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容。

面向过程面向对象

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向过程就是一个问题被解决的自上而下的步骤实现；面向对象就是将解决问题的一些动作封装起来，赋予给一个对象，这个对象有解决的方法和一定的工作流程。

举例：五子棋

面向过程的设计思路就是首先分析问题的步骤：
1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。
而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为：1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

举例：洗衣服

面向过程：
将衣服丢进盆里→放洗衣液→放水→洗衣服→倒掉脏水→再放水→再清洗→拧干衣服→晾晒
面向对象：
把衣服放进洗衣机→放洗衣液→(洗衣机.放水()→洗衣机.洗衣服()→洗衣机.倒掉脏水()→洗衣机.再放水()→洗衣机.再清洗()→洗衣机.拧干衣服())→晒衣服

优缺点
面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、
Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
缺点：性能比面向过程低

Union

https://www.runoob.com/cprogramming/c-unions.html

#include 
#include 
 
union Data
{
   int i;
   float f;
   char  str[20];
};
 
int main( )
{
   union Data data;        
 
   data.i = 10;
   data.f = 220.5;
   strcpy( data.str, "C Programming");
 
   printf( "data.i : %d\n", data.i);
   printf( "data.f : %f\n", data.f);
   printf( "data.str : %s\n", data.str);
 
   return 0;
}

data.i : 1917853763
data.f : 4122360580327794860452759994368.000000
data.str : C Programming

在这里，我们可以看到共用体的 i 和 f 成员的值有损坏，因为最后赋给变量的值占用了内存位置，这也是 str 成员能够完好输出的原因。

const修饰成员函数

常函数：

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

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数

常数据成员

常数据成员必须进行初始化，并且不能被更新
常数据成员只能通过构造函数的参数初始化表对常数据成员进行初始化

面向对象和面向过程：

区别

C是面向过程的语言，C++是在C语言的基础上开发的一种面向对象编程语言，应用广泛。C中函数不能进行重载，C++函数可以重载。C++在C的基础上增添类，C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。
C++中struct和class除了默认访问权限外，别的功能几乎都相同。
C++ 几乎是 C 的超集，只有少量功能 C++ 不支持。
其实跟面向对象和面向过程没有必然联系，c也可以写出面向对象的程序，反之亦然。c++增加了很多语法和封装，方便写出面向对象的程序，比如class，等等。鉴于他们的先后顺序，你可以把C++理解成C的一种面向对象方言。。。一些细节

C语言中struct和union的区别是什么？

结构体与联合体虽然都是由多个不同的数据类型成员组成的，但不同之处在于联合体中所有成员共用一块地址空间，即联合体只存放了一个被选中的成员，而结构体中所有成员占用空间是累加的，其所有成员都存在，不同成员会存放在不同的地址。所以结构体在计算一个结构型变量的总长度时，其内存空间大小等于所有成员长度之和（需要考虑字节对齐），而在联合体中，
所有成员不能同时占用内存空间，它们不能同时存在，所以一个联合型变量的长度等于其最长的成员的长度。
对于联合体的不同成员赋值，将会对它的其他成员重写，原来成员的值就不存在了，而对结构体的不同成员赋值是互不影响的。

C和C++中struct的区别是什么？

C语言中的struct与C++中的struct的区别表现在以下3个方面：

C语言的struct不能有函数成员，而C++的struct可以有。
C语言的struct中数据成员没有private、public和protected访问权限的设定，而C++的struct的成员有访问权限设定。
C语言的struct是没有继承关系的，而C++的struct却有丰富的继承关系。
C语言中的struct是用户自定义数据类型，它是没有权限设置的，它只能是一些变量的集合体，虽然可以封装数据却不可以隐藏数据，而且成员不可以是函数。为了和C语言兼容，C++中就引入了 struct关键字。C++语言中的struct是抽象数据类型 (ADT)，它支持成员函数的定义，同时它增加了访问权限，它的成员函数默认访问权限为 public。

C++中的 struct与class的区别是什么？

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

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

简单描述一下你认为的C语言的优点和缺点

优点

效率高、灵活、可移植
允许直接访问物理地址，对硬件进行操作。

缺点

程序可能难理解 C语言的缺点主要表现在数据的封装性上，这一点使得C在数据的安全性上有很大缺陷，这也是C和C++的一大区别。
C语言表达方面的自由会增加风险。尤其是C语言对指针的使用。
C语言的语法限制不太严格，对变量的类型约束不严格，影响程序的安全性，对数组下标越界不作检查等。

C++是不是类型安全的

不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。

谈谈你是怎么认识 C++ 中的模板的？

模板使程序员能够快速建立具有类型安全的类库集合和函数集合，它的实现，方便了大规模的软件开发。（结合stl更好）

C++中所有的运算符都能重载吗？

在 C++运算符集合中，有一些运算符是不允许被重载的。这种限制是出于安全方面的考虑，可防止错误和混乱。

（1）不能改变 C++内部数据类型（如 int,float 等）的运算符。

（2）不能重载‘.’，因为‘.’在类中对任何成员都有意义，已经成为标准用法。

（3）不能重载目前 C++运算符集合中没有的符号，如#,@,$等。原因有两点，一是难以理解，二是难以确定优先级。

（4）对已经存在的运算符进行重载时，不能改变优先级规则，否则将引起混乱。

c++多态的概念

拿一个父类的指针去调用子类中被重写的方法。目的：是为了面向接口编程。

C++封装的概念

C语言中的struct是用户自定义数据类型，它是没有权限设置的，它只能是一些变量的集合体，虽然可以封装数据却不可以隐藏数据，而且成员不可以是函数。为了和C语言兼容，C++中就引入了 struct关键字。C++语言中的struct是抽象数据类型 (ADT)，它支持成员函数的定义，同时它增加了访问权限，它的成员函数默认访问权限为 public。