构造函数
-
构造函数
1.函数名和类名相同
2.没有返回值
3.如果不写构造函数,任何类中都存在一个默认的构造函数
-默认构造函数是无参的
-当我们直接写了构造函数,默认构造函数就不存在
4.构造函数在构造对象时候调用
5.delete可以用来删掉默认的函数
6.指定使用默认的无参构造函数,用default说明
7.允许构造函数调用另一个构造函数,只是要用初始化参数列表写法
8.初始化参数列表:只有构造函数有
-构造函数名(参数1,参数2,·····):成员1(参数1),成员2(参数2),·····{} -
构造函数用来干啥的
1.构造函数用来构造对象
2.构造函数更多是用来初始化数据成员 -
思考
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="大瓜";
int age=20;
};
//为了能构造不同的对象,我们会给构造函数做缺省处理
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 = "小瓜";
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("小瓜", 18);
mm.print();
MM girl;
girl.print();
Boy boy1;
Boy boy2("小瓜");
Boy boy3("大瓜", 18);
TT tt;
tt.print();
return 0;
}
析构函数
-
析构函数
1.无返回值
2.无参数
3.函数名:~类名
4.不写的话会存在一个默认的析构函数
5.析构函数不需要自己调用,对象死亡之前会调用析构函数 -
析构函数用来干嘛?(什么时候需要自己手动写析构函数)
1.当类中的数据成员是指针,并且动态申请内存需要手动写析构
2.析构函数用来释放数据成员申请动态内存
#include <iostream>
#include <cstring>
#include <string>
using namespace std;
class student
{
public:
student(const char* mname, int age) :age(age)
{
name = new char[sizeof(mname) + 1];
strcpy_s(name, sizeof(mname) + 1, mname);
}
~student()
{
delete[]name;
cout << "析构函数" << endl;
}
void print()
{
cout << name << "\t" << age << endl;
}
protected:
char* name;
int age;
};
int main()
{
student MM("小瓜",18);
MM.print();
return 0;
}
拷贝构造函数
-
拷贝构造函数也是构造函数,长相和构造函数一样,只是参数固定
1.拷贝构造函数唯一的参数是对对象引用 -
不写拷贝构造函数,也存在一个默认的拷贝构造函数
-
拷贝构造函数作用:通过一个对象去初始化另一个对象
-
什么时候调用拷贝构造?
1.当通过一个对象去创建出来另一个新的对象的时候需要调咏拷贝 -
拷贝构造什么时候需要加const修饰参数?
1.当存在匿名对象赋值操作的时候,必须要和加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)
{
name = mm.name;
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("小瓜", 18);
mm.print();
//显示调用
cout << "显示调用" << endl;
MM girl(mm);
girl.print();
cout << endl;
//隐式调用
cout << "隐式调用" << endl;
MM girl2 = mm;//拷贝构造
girl2.print();
cout << endl;
MM girl3;
girl3 = mm;//运算符重载
girl3.print();
cout << endl;
//函数传参
cout << "第一种调用形态" << endl;
printData(mm);
cout << "第二种调用形态" << endl;
printData2(mm);
cout << endl;
//无名对象,匿名对象
MM temp;
temp = MM("匿名",18);//转交匿名对象所有权,只能用temp来调用了
temp.print();
cout << endl;
//匿名对象创建对象时候,拷贝构造一定要用const修饰
MM temp2 = MM("匿名", 199);
temp2.print();
return 0;
}
深浅拷贝
- 浅拷贝:默认的拷贝构造叫浅拷贝
- 深拷贝:拷贝构造函数中做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):age(object.age)
{
name = new char[strlen(object.name) + 1];//深拷贝需要再一次申请内存
strcpy_s(name, strlen(object.name) + 1, object.name);
}
~MM()
{
delete[]name;
name = nullptr;
}
protected:
char* name;
int age;
};
int main()
{
{
MM mm("小瓜", 18);
MM girl(mm);
MM gm = mm;
mm.print();
girl.print();
gm.print();
}
return 0;
}
构造和析构顺序问题
- 普通对象,构造和析构顺序相反
- new出来的对象,delete会直接调用析构函数
- static对象,当程序关闭的时候,生命周期才会结束,所以最后释放
#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
MM(string = "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;
}