1. 构造函数
1.1 构造函数长什么样子
(1) 函数名和类名相同
(2) 没有返回值
(3) 如果不写构造函数，任何类中都存在一个默认的构造函数
I 默认的构造函数是无参的
II 当我们自己写了构造函数，默认的构造函数就不存在
(4) 构造函数在构造对象的时候调用
(5) delete可以用来删掉默认的函数
(6) 指定使用默认的无参构造函数，用default说明
(7) 允许构造函数调用另一个构造函数，只是要用初始化参数列表的写法
(8) 初始化参数列表 ： 只有构造函数有
I 构造函数名(参数1，参数2,…):成员1(参数1)，成员2(参数2),…{}
II 避免形参名和数据成员名相同的导致问题
1.2 构造函数干嘛的
(1) 构造函数用来构造对象
(2) 构造函数更多是用来初始化数据成员
1.3 思考
(1)为什么不写构造函数可以构造对象? 是因为存在一个默认的无参构造函数，所以可以构造无参对象
(2) 构造函数重载为了什么? 为了构造不同长相的对象。
#include <iostream>
using namespace std;
class MM
{
public:
//MM() = delete; 删掉默认的构造函数
MM(string mmName, int mmAge)
{
name = mmName;
age = mmAge;
cout << "带参构造函数" << endl;
}
//MM()
//{
// cout << "无参构造函数" << endl;
//}
MM() = default; //使用的是默认无参构造函数
void print()
{
cout << name << " " << age << endl;
}
protected:
string name="Lisa";
int age=18;
};
//为了能够构造不同长相的对象，我们会给构造函数缺省处理
class Boy
{
public:
//Boy(string mname="", int mage=19)
//{
// name = mname;
// age = mage;
//}
//上面函数 等效可以实现下面三个函数的功能
Boy() {}
Boy(string mName) { name = mName; }
//出错：没有与之匹配的构造函数
Boy(string mName, int mage) { name = mName; age = mage; }
protected:
string name;
int age;
};
//初始化参数列表的写法
string girlName = "Baby";
class Student
{
public:
Student(string mname="", int mage=18) :name(mname), age(mage)
{
cout << "初始化参数列表" << endl;
//继承和类的组合必须采用初始化参数列表写法
}
Student(int mage) :name(girlName), age(mage) {}
protected:
string name;
int age;
};
//构造函数可以调用另一个构造函数初始化数据
class TT
{
public:
TT(string name, int age) :name(name), age(age) {}
//委托构造：允许构造函数调用另一个构造函数
TT():TT("默认",18) {} //没有给数据初始化
void print()
{
cout << name << "\t" << age << endl;
}
protected:
string name;
int age;
};
int main()
{
//MM mm; 构造无参的对象，需要无参构造函数
MM mm("mm", 28);
mm.print();
MM girl;
girl.print();
Boy boy1;
Boy boy2("流浪之子");
Boy boy3("王子", 18);
TT tt;
tt.print();
return 0;
}
2. 析构函数
2.1 析构函数长什么样子?
(1) 无返回值
(2) 无参数
(3) 函数名: ~类名
(4) 不写的话会存在默认的析构函数
(5) 析构函数不需要自己 调用，对象死亡的之前会调用析构函数
2.2 析构函数用来干嘛?（什么时候需要自己手动写析构函数）
(1) 当类中的数据成员是指针，并且动态申请内存就需要手写析构
(2) 析构函数用来释放数据成员申请动态内存
3. 拷贝构造函数
-> 拷贝构造函数也是构造函数，长相和构造函数一样的，只是参数是固定 .拷贝构造函数唯一的参数是对对象引用
-> 不写拷贝构造函数，也存在一个默认的拷贝构造函数
-> 拷贝构造函数作用: 通过一个对象去初始化另一个对象
问题
I 什么时候调用拷贝构造?
答：当通过一个对象去创建出来另一个新的对象时候需要调用拷贝
II 拷贝构造什么时候需要加const修饰参数？
答：当存在匿名对象赋值操作的时候，必须要const修饰
#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
MM() = default;
MM(string name, int age) :name(name), age(age) {}
void print()
{
cout << name << "\t" << age << endl;
}
//拷贝构造
MM(const MM& mm) //MM girl(mm);
{
name = mm.name; //girl.name=mm.name
age = mm.age; //girl.age=mm.age
cout << "拷贝构造" << endl;
}
protected:
string name;
int age;
};
void printData(MM mm) //MM mm=实参;
{
mm.print();
}
void printData2(MM& mm) //不存在拷贝本
{
mm.print();
}
int main()
{
MM mm("mm", 18);
mm.print();
//显示调用调用
cout << "显示调用调用" << endl;
MM girl(mm); //通过一个对象创建另一个对象
girl.print();
//隐式调用
cout << "隐式调用" << endl;
MM girl2 = mm; //拷贝构造
girl2.print();
MM girl3;
girl3 = mm; //运算符重载
girl3.print();
//函数传参
cout << "第一种调用形态" << endl;
printData(mm);
cout << "第二种调用形态" << endl;
printData2(mm);
//无名对象 匿名对象
MM temp;
temp = MM("匿名", 18);
temp.print();
//匿名对象创建对象时候，拷贝构造一定要用const修饰
MM temp2 = MM("匿名", 199);
return 0;
}
4. 深浅拷贝
（1）浅拷贝: 默认的拷贝构造叫做浅拷贝
（2）深拷贝: 拷贝构造函数中做了new内存操作，并且做拷贝赋值的操作
#include<iostream>
#include <cstring>
#include <string>
using namespace std;
class MM
{
public:
MM(const char* mname, int age) :age(age)
{
name = new char[strlen(mname) + 1];
strcpy_s(name, strlen(mname) + 1, mname);
}
void print()
{
cout << name << "\t" << age << endl;
}
MM(const MM& object)
{
//name = object.name;
name = new char[strlen(object.name) + 1];
strcpy_s(name, strlen(object.name) + 1, object.name);
//name = object.name;
age = object.age;
}
~MM()
{
delete[] name;
}
protected:
char* name;
int age;
};
int main()
{
{
MM mm("baby", 19);
MM girl(mm);
MM gm = mm;
mm.print();
girl.print();
gm.print();
}
return 0;
}
5. 构造和析构顺序问题
（1）普通对象，构造顺序和析构顺序是相反
（2）new出来的对象，delete会直接调用析构函数
（3）static对象，当程序关闭的时候，生命周期才结束，所以是最后释放
#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
MM(string name="x") :name(name) {
cout << name;
}
~MM(){
cout << name;
}
protected:
string name;
};
int main()
{
{
MM mm1("A"); //A
static MM mm2("B"); //B 程序关闭时候才死亡，最后析构
MM* p3 = new MM("C"); //C
MM mm4[4]; //xxxx
delete p3; //C delete 直接调用析构
p3 = nullptr;
//xxxxAB
}
//ABCxxxxCxxxxAB
return 0;
}
6. C++结构体
#include <iostream>
#include <string>
using namespace std;
struct MM
{
//默认为公有属性
//类中默认属性是私有属性
//protected:
string name;
int age;
public:
MM(string name) :name(name)
{
cout << "构造函数" << endl;
}
MM(const MM& object)
{
name = object.name;
age = object.age;
cout << "拷贝构造" << endl;
}
~MM()
{
}
};
int main()
{
//采用创建时候赋值的方式，也是调用构造函数
//MM object = { "lisa",19 }; 错误，因为没有两个参数的构造函数
MM object = { "lisa" };
cout << object.name << "\t" << object.age << endl;
//C++结构体一旦写了构造函数，就必须按照C++类的方式的去用
MM mm(object);
cout << mm.name << "\t" << mm.age << endl;
return 0;
}
答疑：
- 为什么要手动写析构函数? 因为默认的不会释放数据成员动态申请的内存
- 函数名和类型相同函数叫做构造函数
- 函数名字是~类名的无参函数叫做析构函数
- 以对象的引用为参数的构造函数叫做拷贝构造函数(复制构造函数)
- 怎么写出来，默认的构造函数，就是那种在没有传参的时候的那一串垃圾值
class Boy
{
public:
Boy() {}
void print()
{
cout << a << "\t" << b << "\t" << c << endl;
}
protected:
int a;
int b;
int c;
};
int main()
{
return 0;
}
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注编程网的更多内容!
