c++~第3课-----构造函数

Luckys-Yang

已于 2022-02-06 16:25:31 修改

阅读量422

点赞数

分类专栏： c++ 文章标签： c++ 开发语言后端

于 2022-02-01 20:19:09 首次发布

本文链接：https://blog.csdn.net/m0_61327008/article/details/122760488

版权

c++ 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

构造函数概念：

1、构造函数概念
一个类的对象被创建的时候，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作。因此，构造函数的核心作用就是，初始化对象的数据成员

构造函数长什么样的？

函数名和类名相同

没有返回值(连void也没有)

如果不写构造函数，任何类中都存在一个默认的构造函数

默认的构造函数是无参的。

构造函数在构造对象的时候调用

delete可以删掉默认的函数

指定使用默认的无参构造函数，用default说明

允许构造函数调用另一个构造函数,只是要用初始化参数列表的写法

初始化参数列表：只有构造函数有：构造函数(参数1，参数2...):成员1(参数1),成员2(参数2),...{}

作用：避免形参名和数据成员名相同导致的问题

当我们自己写了构造函数，默认的构造函数就不存在

构造函数干嘛的？

构造函数用来构造对象

构造函数更多是用来初始化数据成员

构造函数重载为了什么？

为了构造不同长相的对象

class MM
{
public:
	MM() = delete;//删除默认构造函数
	void print()
	{
		cout << name << age << endl;
	}
protected:
	string name;
	int age;

};
int main()
{
	MM mm;//E1790	无法引用 "MM" 的默认构造函数 -- 它是已删除的函数


	return 0;
}

构造有参，无参，重载函数

#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
class MM
{
public:
	//MM() = delete;//删掉默认构造函数
	void print()
	{
		cout << name << age << endl;
	}
	//有参构造函数
	MM(string mmName, int mmAge)
	{
		name = mmName;
		age = mmAge;
		cout << mmName << mmAge << endl;
	}
	//无参构造函数
	MM()
	{
		cout << "无参函数" << endl;
	}
	//MM() = default;//使用的是默认无参构造函数
protected:
	string name;
	int age=1;

};
//为了能够构造不同长相的对象，我们会给构造函数缺省处理
class boy
{
public:
	//如果出错：没有与之匹配的构造函数  原因：没构造函数
	/*boy(string Bname=" ", int Bage=20)
	{
		name = Bname;
		age = Bage;
		cout << Bname << "\t" << Bage << endl;
	}*/
	//上面函数等效下面三个函数功能
	boy(){}
	boy(string Bname) { name = Bname; }
	boy(string Bname, int Bage) { name = Bname; age = Bage; }
	void print()
	{
		cout << name << "\t" << age << endl;
	}
protected:
	string name="默认值";
	int age=11;

};
int main()
{
	//构造无参的对象，需要无参构造函数
	//MM mm;//E1790	无法引用 "MM" 的默认构造函数 -- 它是已删除的函数
	MM mm("大聪明", 22);
	MM m2;
	boy b1;
	b1.print();
	boy b2("熊出没");
	b2.print();
	boy b3("小狗", 66);
	b3.print();
	return 0;
}

初始化列表

在定义带参构造函数时，可以两种写法，都可以进行传参。
（1）正常写法（2）初始化列表写法

class boy
{
public:
	//初始化参数列表
	boy(string Bname, int Bage) :name(Bname), age(Bage)//不一定是源自于左边的参数，也可以是外部的参数类型一样即可
	{
		cout <<"初始化参数列表" << endl;
		//继承和类的组合必须采用初始化参数列表写法
	}
	//正常写法
	boy(string Bname, int Bage)
	{
		name = Bname;
		age = Bage;
		cout << "正常" << endl;

	}

构造函数调用另一个构造函数初始化数据

#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
class boy
{
public:
	//初始化参数列表
	boy(string Bname, int Bage) :name(Bname), age(Bage)//不一定是源自于左边的参数，也可以是外部的参数类型一样即可
	{
		cout <<"初始化参数列表" << endl;
		//继承和类的组合必须采用初始化参数列表写法
	}
	//正常写法
	boy(string Bname, int Bage)
	{
		name = Bname;
		age = Bage;
		cout << "正常" << endl;

	}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
protected:
	string name="默认值";
	int age=11;
};
//构造函数蓝羽调用另一个构造函数初始化数据
class TT
{
public:
	TT(string name, int age) :name(name), age(age){}//形参实参名字可以一样系统会自动识别
	//委托构造
	TT():TT("默认",11){}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};

析构函数：

析构函数长什么样子？

①无返回值②无参数③函数名:~类名④不写的话会存在默认的析构函数⑤析构函数不需要直接调用，对象死亡之前会调用析构函数

析构函数用来干嘛？

什么时候需要自己手动写析构函数；当类中的数据成员是指针，并且动态申请类内存就需要手动写析构；析构函数用来释放数据成员申请动态内存（一个对象出生的时候，使用构造函数，死掉的时候，使用析构函数。）

#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
class MM
{
public:
	MM(const char* pstr, int age) :age(age)
	{
		str = new char[strlen(pstr) + 1];
		strcpy(str, pstr);
	}
	void print()
	{
		cout << str << "\t" << age << endl;
	}
	~MM();
protected:
	char* str;
	int age;
};
MM::~MM()
{
	cout << "我是析构函数" << endl;
	delete[] str;
}
int main()
{
	{
		MM mm("张三", 111);
		mm.print();
		//mm.~MM();//可以手动调但是会引发二次释放问题引发中断
	}//出作用域前调用析构函数
	cout << "主函数" << endl;
	//new一个对象的时候，只有delete 才会调用析构函数
	{
		MM* pp = new MM("你好", 99);
		pp->print();
		delete pp;
		pp = nullptr;
	}

	return 0;
}

拷贝构造函数

拷贝构造函数也是构造函数，长相和构造函数一样的，只是参数是固定

拷贝构造函数唯一的参数是对对象引用

不写拷贝构造函数，也存在一个默认的拷贝构造函数
拷贝构造函数作用：通过一个对象去初始化另一个对象
问题：

什么时候调用？

答：当通过一个对象去创建出来类一个新的对象时候需要调用拷贝。

拷贝构造什么时候需要加const修饰参数？

答:当存在匿名对象赋值操作的时候，必须要const修饰。

#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
class MM
{
public:
	MM(string name, int age) :name(name), age(age)
	{
		cout << "拷贝构造" << endl;
	}
	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;
	}
	MM(){}
	//MM(MM&& 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("效果", 11);
	mm.print();
	//默认拷贝构造函数
	//显示调用
	MM girl(mm);//通过一个对象创建另一个对象
	girl.print();
	cout << "显示调用" << endl;
	//隐式调用
	MM girl2 = mm;//拷贝构造
	girl2.print();
	cout << "隐式调用" << endl << endl;;
	//运算符重载,需要建个无参默认函数，不然会报错(运算符重载不会调用拷贝构造)
	MM girl3;
	girl3 = mm;
	girl3.print();
	//函数传参
	cout << endl;
	cout << "第一种调用形态" << endl;
	printData(mm);
	cout << "第二种调用形态" << endl;
	printData2(mm);

	//无名对象(匿名对象),在创建对象时，拷贝构造移动要加const修饰
	//MM temp = MM("匿名", 11);//不能调用拷贝构造,但是可以加const就可以
	cout << endl;
	MM temp;
	temp = MM("匿名", 11);
	temp.print();

	return 0;
}

深浅拷贝

值是没深浅拷贝的说法，只有指针有影响。

浅拷贝：默认的拷贝构造叫做浅拷贝

深拷贝：拷贝构造函数中做了new内存操作，并且做了拷贝赋值操作（把值拷贝到新的内存里）

#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
class MM
{
public:
	MM(const char* mname, int age):age(age)
	{
		name = new char[strlen(mname) + 1];
		strcpy(name, mname);
	}
	MM(const MM& object)
	{
		//name = object.name;
		name = new char[strlen(object.name) + 1];
		strcpy(name,object.name);
		//name = object.name;//屏蔽上面这一句只new一个内存也不叫深拷贝，还是浅拷贝
		age = object.age;
	}
	~MM()
	{
		delete[] name;
	}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
protected:
	char* name;
	int age;

};
int main()
{
	//浅拷贝
	MM mm("熊出没", 444);//一起运行会崩溃因为调用了三次析构
	MM girl(mm);
	MM girl2 = mm;

	return 0;
}

构造和析构顺序问题

普通对象，构造顺序和析构顺序是相反的。
new出来的对象，delete会直接调用析构函数
static对象，当程序关闭的时候，生命周期才结束，所以是最后释放

#include <iostream>
#include <string>
#include <cstdio>
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* p = new MM("C");//C
		MM mm4[4];//xxx
		delete p;//C,delete是直接调用析构的
	}
	

	return 0;
}

c++结构体：

#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
struct MM
{
	//结构体默认公有属性
	//类中默认私有
//protected:
	string name;
	int age;

	MM(string name) :name(name)
	{
		cout << "构造函数" << endl;
	}

	MM(const MM& object)
	{
		name = object.name;
		age = object.age;
		cout << "拷贝函数" << endl;
	}
};
int main()
{
	//采用创建时候赋值方式，也是调用构造函数
	//MM object = { "你好",11};  //错误，因为没有两个参数的构造函数
	MM object = { "你好" };
	cout << object.name << "\t" << object.age << endl;
	//c++结构体一旦写了构造函数，就必须按照c++类的方式去用
	MM mm(object);

	return 0;
}

Luckys-Yang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
c++~第3课-----构造函数

目录构造函数概念：构造有参，无参，重载函数初始化列表析构函数：拷贝构造函数深浅拷贝构造和析构顺序问题c++结构体：构造函数概念：1、构造函数概念一个类的对象被创建的时候，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作。因此，构造函数的核心作用就是，初始化对象的数据成员构造函数长什么样的？函数名和类名相同没有返回值(连void也没有)如果不写构造函数，任何类中都存在一个默认的构造函数默认的构造函数是无参的。...
复制链接

扫一扫