C++构造和析构函数

最新推荐文章于 2023-07-27 00:44:10 发布
最新推荐文章于 2023-07-27 00:44:10 发布
阅读量1.1k 收藏 4
点赞数 1
分类专栏： C++笔记 文章标签： c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54492880/article/details/121435193
版权

目录

一、构造函数

        1.构造函数的样子

        2.默认构造函数的特点

        3.构造函数的使用

        4.构造函数的用途

        5.*思考题*        

二、析构函数

        1.析构函数的样子

        2.析构函数的用途(什么时候需要自己手动写析构函数) 

三、拷贝构造函数 

        1. 拷贝构造函数函数

         2拷贝构造函数作用

        3.*思考题*

四、深浅拷贝   

        1.浅拷贝

        2.深拷贝

五、构造和析构顺序问题

   *事例*        

六、C++结构体

 七、题目

一、构造函数

        1.构造函数的样子

                (1).函数名和类名相同

                (2).没有返回值

class Person
{
public:
	Person(){}//构造函数--->没有返回值
protected:
	string name;
	int age;
};

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

        2.默认构造函数的特点

                (1).默认的构造参数是无参的.

                (2).当我们自己写了构造函数后，默认的构造函数就不存在了.

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person(string mName,int mAge)//构造函数
	{
		name = mName;
		age = mAge;
	}
	void print()
	{
		cout <<name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};
int main()
{
	Person MM = { "Miss Du", 19 };//自己定义构造函数后可以赋值
	//Person GG; --->报错，因为自己定义了构造函数后默认构造函数不存在了
	MM.print();
	while (1);
	return 0;
}

        3.构造函数的使用

                (1).构造函数在构造对象的时候使用.

                (2).delete可以删掉默认构造函数.

class test{
public:
	test() = delete;//删除默认构造函数
protected:
	string name;
	int age;
};
int main()
{
	//test mm;--->无法构造，因为默认构造函数已经删除    构造无参的对象，需要无参构造函数
	while (1);
	return 0;
}

                (3).当自己写了构造函数后还想使用默认构造函数，可以用default说明.

class Person
{
public:
	Person(string mName,int mAge)
	{
		name = mName;
		age = mAge;
	}
	Person() = default;//默认构造函数仍可使用
	void print()
	{
		cout <<name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};
int main()
{
    Person MM = { "Miss Du", 19 };//自己定义构造函数后可以赋值
	Person GG; //仍然可以调用默认构造函数
	MM.print();
	GG.print();
    while(1);
    return 0;
}

                (4).允许构造函数调用另一个构造函数，只是要用初始化参数列表的写法.(推荐)

class Person
{
public:
	/*Person(string mName,int mAge)
	{
		name = mName;
		age = mAge;
	}*/
	//等价于上面这种写法
	Person(string mName,int mAge):name(mName),age(mAge)
	{
		cout << "我是初始化参数列表的写法" << endl;
	}
	Person() = default;//默认构造函数仍可用
	void print()
	{
		cout <<name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};

   注意点：

         ●  即使不调用另一构造函数时，也可以这种方法，因此构造函数推荐使用初始化参数列表的写法.    

        ●  只有构造函数有初始化参数列表的写法.(构造函数名(参数1，参数2,...):成员1(参数1)，成员2(参数2),...{} )---->成员中的参数也可以使用全局变量来赋值.

        ●  可以避免形参名和数据成员名相同的导致问题.    

string baby="baby";
class test{
public:
	test() = delete;
	test(int mAge) :name(baby), age(mAge){}
    //等价于下面
    test(stirng mName,int mAge):name(mName),age(mAge){}
protected:
	string name;
	int age;
};

        4.构造函数的用途

                (1).用来构造对象

                (2).更多用于初始化成员数据(见以上代码)

        5.*思考题*        

                (1).为什么不写构造函数可以构造对象?

                        这是因为存在一个默认的无参构造函数，所以可以构造无参对象.

                (2).构造函数重载为了什么?

                        为了构造不同长相的对象.

二、析构函数

        1.析构函数的样子

                (1).没有返回值

                (2).没有参数

                (3).函数名：~类名

class test{
public:
	test(string mName, int mAge) :name(mName), age(mAge)
	{
		cout << "我是初始化参数列表的写法" << endl;
	}
	~test();//析构函数
protected:
	string name;
	int age;
};

        注：

                ● 不写析构函数的话会存在默认的析构函数.

                ● 析构函数不需要自己 调用，对象死亡的之前会调用析构函数. 

        2.析构函数的用途(什么时候需要自己手动写析构函数) 

                (1).当类中的数据成员是指针，并且动态申请内存就需要手写析构.

                (2).析构函数用来释放数据成员申请动态内存. 

#include<iostream>
#include<string>
#include<cstring>
using namespace std;
class Person
{
public:
	Person(const char*mName,int mAge) :age(mAge)
	{
		name = new char[strlen(mName) + 1];
		strcpy(name, mName);
	}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
	/*~Person()
	{
		cout << "我是析构函数" << endl;
		delete[] name;
	}*/
	//等价于下面
	~Person();//类中声明，类外定义
protected:
	char* name;
	int age;
};
Person::~Person()
{
	cout << "我是析构函数" << endl;
	delete[] name;
}
int main()
{
	{
		Person MM("Miss Du", 19);
		MM.print();
	}
	cout << "主函数" << endl;
	while (1);
	return 0;
}

三、拷贝构造函数 

        1. 拷贝构造函数函数

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

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

                 (2). 不写拷贝构造函数，也存在一个默认的拷贝构造函数

         2拷贝构造函数作用

                        ● 通过一个对象去初始化另一个对象         

class Person
{
public:
	Person(string mName, int mAge) :name(mName), age(mAge){}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
	//拷贝构造
	Person(Person& MM){							//Person mm(MM)
		name = MM.name;							//mm.name=MM.name
		age = MM.age;							//mm.age=MM.age
		cout << "我是拷贝构造函数" << endl;
	}
protected:
	string name;
	int age;
};
int main()
{
	Person MM("Miss Du", 19);
	MM.print();
	//显式拷贝
	cout << "显式拷贝" << endl;
	Person mm(MM);        //通过一个对象创建另一个对象
	mm.print();
	//等价于下面 --->隐式调用
	/*Person mm = MM;
	mm.print();*/
	while (1);
	return 0;
}

        注：区别运算符重载和拷贝函数

    Person girl;
	girl = MM;
	girl.print();    //此为运算符重载  不会调用拷贝函数 相当于赋值


    Person mm(MM);
	mm.print();    //此为拷贝构造

        3.*思考题*

                (1).什么时候调用拷贝构造?

                        ● 当通过一个对象去创建出来另一个新的对象时候需要调用拷贝

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

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

                注：因此在写拷贝构造函数时一般都会加上const

    //匿名对象 无名对象
	Person GG = Person("Mr Yan", 19);
	GG.print();
	//匿名对象创建对象时候，拷贝构造一定要用const修饰
    Person temp;
	temp = Person("匿名", 18);
	temp.print();

                (3).函数传参

void printData(Person MM) //Person MM=实参 
{
	MM.print();
}
void printData2(Person& MM) //不存在拷贝本
{
	MM.print();
}
int main()
{
    Person MM("Miss Du", 19);
    printData(MM);     //调用了拷贝构造函数
	printData2(MM);    //没有调用
    while(1);
    return 0;
}

四、深浅拷贝   

        1.浅拷贝

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

        2.深拷贝

                ● 拷贝构造函数中做了new内存操作，并且做拷贝赋值的操作

#include<iostream>
#include<string>
#include<cstring>
using namespace std;
class Person
{
public:
	Person() = default;
	Person(const char* mName, int mAge) :age(mAge)
	{
		name = new char[strlen(mName) + 1];
		strcpy(name, mName);
	}
	Person(const Person& MM)
	{
		//name = object.name;
		name = new char[strlen(MM.name) + 1];//需要深拷贝
		strcpy(name , MM.name);
		age = MM.age;
	}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
	~Person()//自己写的析构函数
	{
		delete[] name;
	}

protected:
	char* name;
	int age;
};
int main()
{
	Person MM("Miss Du", 19);
	Person girl(MM);
	Person gm = MM;
	girl.print();
	gm.print();
	while (1);
	return 0;
}

五、构造和析构顺序问题

        (1).普通对象构造和析构顺序是相反的.

        (2).new出来的对象，delete会直接调用析构函数.

        (3).static对象，当程序关闭的时候，生命周期才结束，所以是最后释放.

   *事例*        

#include<iostream>
#include<string>
#include<cstring>
using namespace std;
class Person
{
public:
	Person(string name = "x") :name(name) {
		cout << name;
	}
	~Person(){
		cout << name;
	}
protected:
	string name;
};
int main()
{
	{
		Person MM1("A");                    //A
		static Person MM2("B");             //B
		Person* MM3 = new Person("C");      //C
		Person MM4[4];                      //XXXX
		delete MM3;                         //C
		MM3 = nullptr;
	}                                       //XXXXA
	while (1);
	return 0;                               //B
}//最后答案：ABCXXXXCXXXXAB

六、C++结构体

                ● C++结构体中加入构造函数后就可以当做类来看，只是默认属性为public，而类中默认属性为private.

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

 七、题目

        ● 自己手写一个string类，满足以下功能                             

//1.实现string中创建方式
    string str1;
    string str2("ILoveyou");
    string str3(str1);
    string str4 = str2;
//2.通过实现data和c_str函数 打印字符串
    cout << str2.c_str() << endl;  //打印ILoveyou
    cout << str2.data() << endl;   //打印ILoveyou
//3.实现append 实现字符串的链接
    string strOne="one";
    string strTwo="two";
    string strThree=strOne.append(strTwo);
    cout<<strThree.data()<<endl;        //onetwo
//4.实现字符串比较
    cout<<strOne.compare(strOne)<<endl;    //0
//5.手写析构函数释放内存                                                                                                       

#include <iostream>
#include <cstring>
using namespace std;
class mystring
{
public:
	//mystring() 
	//{
	//	strSize = 1;
	//	str = new char;
	//	*str='\0';
	//};
	mystring(const char* str="") 
	{
		strSize = strlen(str) + 1;
		mystring::str = new char[strSize];
		strcpy_s(mystring::str,strSize,str);
	}
	mystring(const mystring& object)
	{
		strSize = object.strSize;
		str = new char[strSize];
		strcpy_s(str, strSize, object.str);
	}
	char* c_str() 
	{
		return str;
	}
	char* data() 
	{
		return str;
	}
	mystring append(const mystring& object)
	{
		mystring temp;
		temp.strSize = mystring::strSize + object.strSize-1;
		temp.str = new char[temp.strSize];
		memset(temp.str, 0, temp.strSize);
		strcat_s(temp.str, temp.strSize, str);
		strcat_s(temp.str, temp.strSize, object.str);
		return temp;
	}
	int compare(const mystring& object) 
	{
		return strcmp(str, object.str);
	}
	~mystring()
	{
		delete[] str;
		str = nullptr;
	}
protected:
	char* str;			//需要存储
	int  strSize;		
};

demons and monsters
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++构造函数和析构函数的使用与讲解
01-20
构造函数(constructor) 1.构造函数是种特殊的类成员函数，遵循如下规则： a.函数名与类名必须相同。...3.构造函数和普通成员函数不一样，一般不显示调用。在创建一个对象时，构造函数自动调用(编译器来完成
包含构造函数和析构函数的C++程序
10-20
本程序包含构造函数和析构函数，可以把构造函数和析构函数的作用区分开
c++：构造函数，析构函数介绍以及初始化的一些说明
a2998658795的博客
07-25 1244
构造函数，析构函数介绍以及初始化的一些说明
【深入理解C++】析构函数
脚踏实地，仰望星空
01-27 1388
析构函数
struct结构体是否有构造和析构函数？
lgs7907
06-26 4790
编者：李国帅 qq：9611153 微信lgs9611153 时间：2011-11-18 自己在结构体的理解方面还是存在偏差的，结构体也是有构造和析构函数的。想当然的认为它没有面向对象的特征是不对的。 公认区别： 从语法上，在C++中（只讨论C++中）, class和struct做类型定义时的区别： （一）默认继承权限。如果不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理； （二）成员的默认访问权限。class的成员默认...
C++构造函数和析构函数
wade1010的专栏
12-06 215
c++
C++构造函数和析构函数顺序
12-22
构造函数 　先看看构造函数的调用顺序规则，只要我们在平时编程的时候遵守这种约定，任何关于构造函数的调用问题都能解决；构造函数的调用顺序总是如下： 　1.基类构造函数。如果有多个基类，则构造函数的调用顺序...
深入解析C++中的构造函数和析构函数
12-31
调用构造函数和析构函数的顺序：先构造的后析构，后构造的先折构。它相当于一个栈，先进后出。 代码如下:#include<iostream>#include<string>using namespace std;class Student{ public: Student(string,string,...
C++ 构造与析构
最新发布
good good study, day day up!
07-27 545
C++中的构造与析构、构造函数、析构函数、拷贝构造、explicit关键字、显示调用、隐式调用
浅析c与c++中struct的区别
01-01
这里有两种情况下的区别。（1）C的struct与C++的class的区别。（2）C++中的struct和class的区别。在第一种情况下，struct与class有着非常明显的区别。C是一种过程化的语言，struct只是作为一种复杂数据类型定义，struct中只能定义成员变量，不能定义成员函数（在纯粹的C语言中，struct不能定义成员函数，只能定义变量）。例如下面的C代码片断： 代码如下:        struct Point        {                int x; // 合法                int y; // 合法                vo
C++中struct也有构造函数与析构函数，也可以有访问类型控制以及结构体大小，类大小
大可的杨先森的博客
03-27 1206
C++中struct也有构造函数与析构函数，也可以有访问类型控制，可以用private关键字。如下所示： [cpp] view plain copy #include         struct point     {     public:         point():x_(0.0),y_(0.0)         {  
【C++入门】(拷贝)构造函数和析构函数
weixin_42031299的博客
10-06 1643
(1)：字面意思就是构造对象的函数，当我们定义类的对象时调用，可以帮我们完成对象的初始化；(2)：可以看做是构造函数的逆过程，当销毁类的时候调用，做一些收尾的工作；比如：定义类的对象时构造函数申请了动态内存，那在销毁对象时调研员的析构函数中就要释放申请的动态内存，否则就会造成内存泄漏；(3)。程序员可以在定义类时使用默认的构造/析构函数，或者自己定义构造/析构函数，但是构造/析构函数的调用却不是程序员主动去调用，而是C++语言自动帮我们调用。
C++ 构造函数和析构函数 详解
热门推荐
a只如初见的博客
08-08 2万+
C++中用构造函数和析构函数来初始化和清理对象，这两个函数将会被编译器自动调用。对象的初始化和清理是非常重要的，如果我们不提供构造函数与析构函数，编译器会自动提供两个函数的空实现。............
C++: 函数返回类对象时是否执行析构函数
qaqwqaqwq的博客
11-17 1753
#include<iostream> using namespace std; struct A { A(){} A(const A&) { cout<<"Copy constructor\n"; } ~A() { cout<<"Destructor\n"; } }; A f() { return A(); } A g() { A a; return .
C++ 结构体构造函数
hk_kang的博客
09-17 1万+
结构体构造函数必须是与结构体名称相同的公共成员函数，并且没有返回类型。 写法和类是类似的。 struct node { int label; node(int x):label(x){} } struct node { int label; node(int x) { label = x; } } 第一个对label的初始...
[031] C++函数返回结构体类型数据
yhxxhy978的博客
06-22 8183
1、代码简介 ① 结构体包含学生的三类信息：年龄，成绩，姓名； ② func函数用于求和各科成绩，并返回总分最高的学生的结构体数据； ③ 关键：用指针等效数组；用结构体指针返回结构体类型数据。 2、代码 ① main.cpp #include <iostream> #include <string> #include <cstdio> #include "func.h" using namespace std; //学生信息赋值 int age1 = 1
C++析构函数
weixin_38956024的博客
02-03 4054
一、什么析构函数 析构函数就是对象被释放的时候被调用的函数。它的本质是回调函数。 什么时候对象会被释放？比如，main执行完退出的时候，delete一个对象指针的时候… 析构函数的特点是，不带返回值，也不带参数。 二、实验 实验一：析构函数的定义方法 //cat.hpp class cat { public: string name; int age; bool male; cat(){this->name = "wawa";}; cat(string name, int age, bo
c++的构造和析构
weixin_30446197的博客
08-18 44
//文件名ss.h 1 #pragma once 2 class ss 3 { 4 private: 5 char*p;//利用指针来为p申请对内存 6 float height; 7 int age=5; 8 char sex; 9 public: 10 ss(); 11 void eat(); ...
c++构造函数和析构函数
06-07
C++中的构造函数和析构函数是用来初始化和清理类对象的特殊成员函数。构造函数在对象被创建时自动调用，而析构函数则在对象被销毁时自动调用。 构造函数的名称与类名称相同，没有返回类型，可以有参数，分为默认构造函数和带参数构造函数。默认构造函数无需参数，用于创建对象时的默认初始化操作；带参数构造函数可以通过参数列表对对象进行初始化。 析构函数的名称与类名称相同，前面加上~符号，没有返回类型和参数。析构函数通常用来释放对象占用的资源，如动态分配的内存、打开的文件等。 例如： ```c++ class MyClass { public: // 默认构造函数 MyClass() { // 对象初始化操作 } // 带参数构造函数 MyClass(int value) { // 对象初始化操作 } // 析构函数 ~MyClass() { // 对象清理操作 } }; ``` 当创建MyClass对象时，会自动调用相应的构造函数；当销毁MyClass对象时，会自动调用析构函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值