黑马程序员：C++核心编程——4(2)

}
//有参构造函数
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(); 就像是 void f()；
//
//2.2 显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后，马上析构
//Person(P3)会重定义，等同于Person P3；

//2.3 隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);这里已经存在P5了，这个调用编译器会认为是对象声明而再创建一个P5，报错

}
int main() {
test02();
system(“pause”);
return 0;
}

### 


#### 2）拷贝构造函数的调用时机


1. 使用一个已经存在的对象初始化另一个
2. 值传递的方式给函数参数传值（创建形参时会调用拷贝构造函数）
3. 以值方式返回局部对象（函数返回类对象局部变量时会调用拷贝构造函数创建一个新的对象并返回这个新的对象）


#### 3）构造函数调用规则


默认情况下，C++编译器会至少给一个类添加三个函数：


1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性值进行浅拷贝


可以将构造函数分为三个等级：默认构造，有参构造，拷贝构造。


**当用户提供了高等级的构造函数的时候，编译器就只提供比它更高等级的构造函数。**


如当用户定义了有参构造之后，c++就不提供默认构造，只提供默认拷贝构造函数。当用户提定义了拷贝构造函数之后，c++就不再提供任何构造函数。


#### 4）深拷贝和浅拷贝


**浅拷贝就是简单的赋值操作**，**深拷贝则要在堆区重新申请空间进行拷贝操作**！


如果有属性是在堆区开辟的，一定要防止浅拷贝让两个对象的这个属性都指向一个堆区空间所带来的重复释放堆区的问题！！！！！

#include
using namespace std;

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

### 


#### 5）初始化列表


用初始化列表来初始化对象属性。

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

### 


#### 6）类对象作为类成员


**可以利用初始化列表来告诉编译器调用哪个对象成员的构造函数**！！！


对象与类成员的构造与析构顺序可以参考栈的特性：**先构造对象成员再构造自身，析构则与构造顺序相反！**（先有零件后有整体）


#### 7）静态成员


静态成员包括静态成员变量和静态成员函数。


1. 静态成员变量：所有的对象共享一份数据（一个地址），在编译阶段分配内存，**类内声明类外初始化**
2. 静态成员函数：所有的对象共享同一个函数（一个地址），**静态成员函数只能访问静态成员变量**（因为这个函数是共享的，不知道要改的非静态属性是哪个对象的）！
3. 注意：私有的静态成员变量也可以在类外初始化但不能访问类外。静态成员函数有两种访问方式，第一种是通过对象，第二种是通过类名。

void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.func();
//2、通过类名
Person::func();
//Person::func2(); //私有权限访问不到
}

### 2.析构函数


析构函数**没有返回值**也不写void，**不可以有参数因此不能重载**，在对象销毁前会调用一次。


**通过析构函数释放掉对象开辟的堆区属性**。


## 4.3 C++对象模型和this指针


### 1.成员变量和成员函数分开存储


1. 只有非静态成员变量才属于类的对象上，存储在对象的地址中。
2. 空对象占有1B，用于标识出有这么一个空对象。当对象不为空时，它的存储空间只包括非静态成员变量且不包括这1B！
3. 所有的成员函数都是只有一份的而非每个对象都有一份。当调用时依靠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;
}

### 2.this指针概念


1. this指针指向被调用的成员函数所属的对象。
2. this指针隐含在每一个非静态成员函数内。
3. this指针本质是一个指针常量，指针的指向不可修改。**Person\* const this**;
4. 用途：


* 当形参和成员变量同名时可以用this指针区分。
* 在类的非静态成员函数中返回对象本身可以使用：**return \*this**;(解引用后返回对象本身)

#include
using namespace std;

class Person
{
public:
Person(int age)
{
//1、当形参和成员变量同名时，可用this指针来区分
this->age = age;
}
Person& PersonAddPerson(Person p)
{
this->age += p.age;
//返回对象本身
return *this;
}
int age;
};
void test01()
{
Person p1(10);
cout << "p1.age = " << p1.age << endl;
Person p2(10);
p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
cout << "p2.age = " << p2.age << endl;
}
int main() {
test01();
system(“pause”);
return 0;
}

**这里有两个需要注意的点:**


第一：为什么可以连续调用这么多次？

p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);

第二：为什么返回引用对象？

Person& PersonAddPerson(Person p)
{
this->age += p.age;
//返回对象本身
return *this;
}

首先这里使用了引用对象，所以可以把p2.PersonAddPerson(p1)看作是p2的一个别名，操作的一直是p2对象指向的地址。也就是引用章节讲的引用作函数返回值时返回的就是return对象的一个别名（甚至整个调用的函数就是它的别名）。


只有返回类型为引用才能返回本体，否则将调用拷贝构造返回一个新的对象。


如果这里的函数返回类型为void则无法调用三次！！！


如果这里的函数返回类型为Person则每次都将产生一个新的对象，而不是在p2上操作！！！


### 3.空指针访问成员函数


**C++中空指针也可以调用类中的成员函数，但一定要注意有没有用到this指针，如果用到了就要加一个判断是否为空指针的环节，否则this无法指向空对象就会报错！！！**

//空指针访问成员函数
class Person {
public:
void ShowClassName() {
cout << “我是Person类!” << endl;
}
void ShowPerson() {
if (this == NULL) {
return;
}
cout << mAge << endl;
}
public:
int mAge;
};
void test01()
{
Person * p = NULL;
p->ShowClassName(); //空指针，可以调用成员函数
p->ShowPerson(); //但是如果成员函数中用到了this指针，就不可以了
}
int main() {
test01();
system(“pause”);
return 0;
}

### 4.**const****修饰成员函数**


**常函数**：


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



**常对象：** 

* 声明对象前加const称该对象为常对象
* **常对象只能调用常函数（因为普通成员函数可以修改成员属性，不能让常对象间接修改成员属性）**


**常对象和常函数是配套的！！！！！**

class Person {
public:
Person() {
m_A = 0;
m_B = 0;
}
//this指针的本质是一个指针常量，指针的指向不可修改
//如果想让指针指向的值也不可以修改，需要声明常函数
void ShowPerson() const {
//本质的意思就是const Type* const this; 但前面这个const思来想去最后加在了{}前面
//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;
}

## 4.4 友元


      假如想让某一些类内的私有数据被类外的一些函数或者类所访问，我们就需要用到友元（好朋友）。即**友元的目的就是让一个类或者函数访问另一个类中的私有成员。**


### 1.友元的三种实现


      **友元的三种实现：全局函数、类、成员函数。**


**1）全局函数**

#include
using namespace std;

class Building
{
//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
friend void goodGay(Building* building); //friend 函数声明;
public:
Building()
{
this->m_SittingRoom = “客厅”;
this->m_BedRoom = “卧室”;
}
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom; //卧室
};
void goodGay(Building* building)
{
cout << "好基友正在访问： " << building->m_SittingRoom << endl;
cout << "好基友正在访问： " << building->m_BedRoom << endl;
}
void test01()
{
Building b;
goodGay(&b);
}
int main() {
test01();
system(“pause”);
return 0;
}

**2）类**

#include
using namespace std;

class Building;
class goodGay
{
public:
goodGay();
void visit();
void visitOut(Building* b);
private:
Building* building;
};
class Building
{
//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
friend class goodGay;
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
//类外实现构造函数和成员函数
Building::Building()
{
this->m_SittingRoom = “客厅”;
this->m_BedRoom = “卧室”;
}
goodGay::goodGay()
{
building = new Building;
}
//友元声明后可以访问类内类成员对象中的私有属性
void goodGay::visit()
{
cout << “好基友正在访问” << building->m_SittingRoom << endl;
cout << “好基友正在访问” << building->m_BedRoom << endl;
}
//友元声明后可以访问类外对象中的私有属性
void goodGay::visitOut(Building* b)
{
cout << “好基友正在访问” << building->m_SittingRoom << endl;
cout << “好基友正在访问” << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit();
}
void test02()
{
goodGay gg;
Building b;
gg.visitOut(&b);
}
int main() {
test01();
test02();
system(“pause”);
return 0;
}

**3）成员函数**

#include
using namespace std;

class Building;
class goodGay
{
public:
goodGay();
void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
void visitOut(Building* b);
void visit2();
private:
Building* building;
};
class Building
{
//告诉编译器 goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
friend void goodGay::visit();
friend void goodGay::visitOut(Building* b);
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
Building::Building()
{
this->m_SittingRoom = “客厅”;
this->m_BedRoom = “卧室”;
}
goodGay::goodGay()
{
building = new Building;
}
void goodGay::visit()
{
cout << “好基友正在访问” << building->m_SittingRoom << endl;
cout << “好基友正在访问” << building->m_BedRoom << endl;
}
void goodGay::visitOut(Building* b)
{
cout << “好基友正在访问” << b->m_SittingRoom << endl;
cout << “好基友正在访问” << b->m_BedRoom << endl;
}
void goodGay::visit2()
{
cout << “好基友正在访问” << building->m_SittingRoom << endl;
//不是友元成员函数不可访问
//cout << “好基友正在访问” << building->m_BedRoom << endl;
}
//友元成员函数可以访问类内类对象的私有属性
void test01()
{
goodGay gg;
gg.visit();
}
//友元成员函数可以访问类外类对象的私有属性
void test02()
{
goodGay gg;
Building b;
gg.visitOut(&b);
}
int main() {
test01();
test02();
system(“pause”);
return 0;
}

## 4.5 运算符重载


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


**汇总：**

//1.加号运算符重载
Person operator+(const Person& p)

//2.左移运算符重载
ostream& operator<<(ostream& cout, Person& p)

//3.递增运算符重载
//前置++
className& operator++()
//后置++
className& operator++(int)

//4.赋值运算符重载
className& operator=(className &p)

//5.关系运算符重载
bool operator==(className &p)
bool operator!=(className &p)

//6.函数调用运算符重载
dataType operator()(dataType1 p1,…,dataTypen pn)

### **1.加号运算符重载**


**这里可以是成员函数实现，也可以是全局函数，而且可以发生重载，非常灵活。**

#include
using namespace std;

class Person {
public:
Person() {};
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数实现 + 号运算符重载
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;
}
public:
int m_A;
int m_B;
};
//全局函数实现 + 号运算符重载
//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;
}
void test() {
Person p1(10, 10);
Person p2(20, 20);
//成员函数方式
Person p3 = p2 + p1; //相当于 p2.operaor+(p1)
cout << “mA:” << p3.m_A << " mB:" << p3.m_B << endl;
Person p4 = p3 + 10; //相当于 operator+(p3,10)
cout << “mA:” << p4.m_A << " mB:" << p4.m_B << endl;
}
int main() {
test();
system(“pause”);
return 0;
}

### 2.左移运算符重载


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


**注意：一般不用成员函数重载**，因为cout不能在左边，会实现成：p << cout；


这里这个函数为什么使用引用参数且返回引用数据类型呢？


答：下面有链式调用，因此如果写成void就不能成功调用。而且我们希望一直返回这个唯一的对象，所以我们一般使用引用来获取这个对象。

#include
using namespace std;

class Person {
//全局函数要访问类内的私有属性，需要是类的友元！！！
friend ostream& operator<<(ostream& out, Person& p);
public:
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数 实现不了 p << cout 不是我们想要的效果
//void operator<<(Person& p){
//}
private:
int m_A;
int m_B;
};
//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
out << “a:” << p.m_A << " b:" << p.m_B;
return out;
}
void test() {
Person p1(10, 20);
cout << p1 << “hello world” << endl; //链式编程
}
int main() {
test();
system(“pause”);
return 0;
}

### 3.递增运算符重载


**作用：实现自己的整型数据。**


**注意：这里的后置不能返回引用，因为返回的是一个临时数据！！！**

#include
using namespace std;

class MyInteger {
friend ostream& operator<<(ostream& out, MyInteger myint);
public:
MyInteger() {
m_Num = 0;
}
//前置++
MyInteger& operator++() {
//先++
m_Num++;
//再返回
return *this;
}
//后置++
MyInteger operator++(int) {
//先返回
//记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++
MyInteger temp = *this;
m_Num++;
return temp;
}
private:
int m_Num;
};
ostream & operator<<(ostream & out, MyInteger myint) {
out << myint.m_Num;
return out;
}
//前置++ 先++ 再返回
void test01() {
MyInteger myInt;
cout << ++myInt << endl;
cout << myInt << endl;
}
//后置++ 先返回 再++
void test02() {
MyInteger myInt;
cout << myInt++ << endl;
cout << myInt << endl;
}
int main() {
test01();
cout<<endl;
test02();
system(“pause”);
return 0;
}

### 4.复制运算符重载


**C++编译器至少给一个类添加4个函数**：


1. **默认构造函数**
2. **默认析构函数**
3. **默认拷贝构造**
4. **赋值运算符operator=**


注意：如果类中有在堆区开辟的属性，也会出现深浅拷贝的问题。（重载就可以解决这个问题）

#include
using namespace std;
class Person
{
public:
Person(int age)
{
//将年龄数据开辟到堆区
m_Age = new int(age);
}
//重载赋值运算符
Person& operator=(Person& p)
{
//首先要判断堆区属性是否已经存在，存在则要先释放掉
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
//编译器提供的代码是浅拷贝
//m_Age = p.m_Age;
//提供深拷贝 解决浅拷贝的问题
m_Age = new int(*p.m_Age);
//返回自身
return this;
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
//年龄的指针
int m_Age;
};
void test01()
{
Person p1(18);
Person p2(20);
Person p3(30);
p1 = p2 = p3; //赋值操作，这里连续赋值需要返回对象本身 从后往前执行p2 = p3,p1 = p2
cout << “p1的年龄为：” << *p1.m_Age << endl;
cout << “p2的年龄为：” << *p2.m_Age << endl;
cout << “p3的年龄为：” << *p3.m_Age << endl;
}
int main() {
test01();
system(“pause”);
return 0;
}

### 5.关系运算符重载


作用：让两个自定义类型对象进行对比操作。

#include
using namespace std;
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
};
bool operator==(Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
else
{
return false;
}
}
bool operator!=(Person& p)
{

为了做好运维面试路上的助攻手，特整理了上百道 【运维技术栈面试题集锦】 ，让你面试不慌心不跳，高薪offer怀里抱！

这次整理的面试题，小到shell、MySQL，大到K8s等云原生技术栈，不仅适合运维新人入行面试需要，还适用于想提升进阶跳槽加薪的运维朋友。

本份面试集锦涵盖了

• 174 道运维工程师面试题
• 128道k8s面试题
• 108道shell脚本面试题
• 200道Linux面试题
• 51道docker面试题
• 35道Jenkis面试题
• 78道MongoDB面试题
• 17道ansible面试题
• 60道dubbo面试题
• 53道kafka面试
• 18道mysql面试题
• 40道nginx面试题
• 77道redis面试题
• 28道zookeeper

总计 1000+ 道面试题， 内容 又全含金量又高

• 174道运维工程师面试题

1、什么是运维?

2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?

3、现在给你三百台服务器，你怎么对他们进行管理?

4、简述raid0 raid1raid5二种工作模式的工作原理及特点

5、LVS、Nginx、HAproxy有什么区别?工作中你怎么选择?

6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?

7、Tomcat和Resin有什么区别，工作中你怎么选择?

8、什么是中间件?什么是jdk?

9、讲述一下Tomcat8005、8009、8080三个端口的含义？

10、什么叫CDN?

11、什么叫网站灰度发布?

12、简述DNS进行域名解析的过程?

13、RabbitMQ是什么东西?

14、讲一下Keepalived的工作原理?

15、讲述一下LVS三种模式的工作过程?

16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?

17、如何重置mysql root密码?

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
51道docker面试题

• 35道Jenkis面试题
• 78道MongoDB面试题
• 17道ansible面试题
• 60道dubbo面试题
• 53道kafka面试
• 18道mysql面试题
• 40道nginx面试题
• 77道redis面试题
• 28道zookeeper

总计 1000+ 道面试题， 内容 又全含金量又高

• 174道运维工程师面试题

1、什么是运维?

2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?

3、现在给你三百台服务器，你怎么对他们进行管理?

4、简述raid0 raid1raid5二种工作模式的工作原理及特点

5、LVS、Nginx、HAproxy有什么区别?工作中你怎么选择?

6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?

7、Tomcat和Resin有什么区别，工作中你怎么选择?

8、什么是中间件?什么是jdk?

9、讲述一下Tomcat8005、8009、8080三个端口的含义？

10、什么叫CDN?

11、什么叫网站灰度发布?

12、简述DNS进行域名解析的过程?

13、RabbitMQ是什么东西?

14、讲一下Keepalived的工作原理?

15、讲述一下LVS三种模式的工作过程?

16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?

17、如何重置mysql root密码?

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！