C++_构造函数和析构函数

最新推荐文章于 2024-02-06 15:01:12 发布

大师兄电子工作室

最新推荐文章于 2024-02-06 15:01:12 发布

阅读量1k

点赞数

分类专栏：编程语言文章标签：构造函数析构函数 C++

本文链接：https://blog.csdn.net/gsh_hello_world/article/details/53126275

版权

编程语言专栏收录该内容

60 篇文章 2 订阅

订阅专栏

概述

构造函数的功能是对对象的初始化,主要是对数据成员初始化,并分配存储空间，注意:应声明为public 类型，因对象创建时，系统自动调用，是通过对象来使用，任何成员只要通过对象使用就属于类外使用；析构函数主要功能是对类中动态分配的内存进行释放,它在对象消失时自动调用。构造函数和析构函数都是类的成员函数。

构造函数

（1）构造函数特征

<1>构造函数的名字与类名相同；

<2>构造函数没有返回值,在声明和定义时不能说明它的类型，甚至void；

<3>构造函数的功能是对对象进行初始化,且一般只对数据成员初始化，一般不能作赋初值以外的事情；

<4>不能像其他成员函数那样被显示调用，在对象创建时被自动调用；

<5>在一个类中可以定义多个构造函数（重载）；

<6>如果一个类没有定义构造函数，编译器会自动生成一个不带参数的默认构造函数，其格式如下：

<类名>::<默认构造函数名>（）

{

}

（2）构造函数的形式有几种:

带参数的构造函数

缺省参数的构造函数

重载构造函数

拷贝构造函数

<1>一般形式的构造函数的应用

student.h

#ifndef STUDENT_H
#define STUDENT_H
#include <iostream>
#include <string.h>
#include <stdio.h>
class student//定义类
{
public:	//类的共有成员
	student();		//构造函数声明
	~student();		//析构函数声明
	void chgName(char *pn);	//修改姓名
	void chgId(char *pid);	//修改学号
	void chgScore(float s);	//修改分数
	void display();	//显示信息
private://类的私有成员
	float score;	//学生成绩
	char *name;		//学生姓名
	char *Id;		//学生学号
};
#endif // STUDENT_H_INCLUDED

stduent.cpp

#include "student.h"
using namespace std;
#pragma warning(disable:4996)
student::student()//构造函数定义
{
	Id = new char[11];			//给变量分配存储空间
	strcpy(Id, "2016140282");	//给变量Id赋值
	name = new char[10];		//给变量分配存储空间
	strcpy(name, "高世皓");		//给变量name赋值
	score = 90;
}
student::~student()
{
	delete [] name;	//释放内存空间
	delete [] Id;	//释放内存空间
}
void student::chgName(char *pn)
{
	delete [] name;
	name = new char[strlen(pn) + 1];//给变量重新分配存储空间
	strcpy(name, pn);
}
void student::chgId(char *pid)
{
	delete [] Id;
	Id = new char[strlen(pid) + 1];//给变量重新分配存储空间
	strcpy(Id, pid);
}
void student::chgScore(float s)
{
	score = s;
}
void student::display()
{
	cout << "id:" << Id << endl;
	cout << "name:" << name << endl;
	cout << "score:" << score << endl;
}

main.cpp

#include "student.h"
int main()
{
	student s;		//定义对象s
	s.display();	//显示初始化值
	s.chgId("2016140283");
	s.chgName("zhangsan");
	s.chgScore(87);
	s.display();
	getchar();
	return 0;
}

<2>带参数的构造函数

在创建对象时通过传递不同的参数，实现对不同对象进行不同的初始化。注意：构造函数的参数个数和类型规定了声明一个对象时，对这个对象进行初始化所需要的初始值的个数和类型。

#include<iostream>
using namespace std;
class point
{
public:
	point(int vx, int vy);//声明带参数的构造函数
	void offset(int ax, int ay);
	void display();//显示坐标
private:
	int x;
	int y;
};
int main()
{
	point p(10, 10);
	p.display();
	p.offset(10, 10);
	p.display();
	getchar();
	return 0;
}
point::point(int vx, int vy)
{
	x = vx;
	y = vy;
}
void point::offset(int ax, int ay)
{
	x = x + ax;
	y = y + ay;
}
void point::display()
{
	cout << "x = " << x << endl;
	cout << "y = " << y << endl;
}

带参数构造函数的应用

student.h

#ifndef STUDENT_H
#define STUDENT_H
#include <iostream>
#include <string.h>
#include <stdio.h>
class student//定义类
{
public:	//类的共有成员
	student();		//不带参数的构造函数声明
	student(char *pn, char *pid, float s);//带参数的构造函数声明
	~student();		//析构函数声明
	void chgName(char *pn);	//修改姓名
	void chgId(char *pid);	//修改学号
	void chgScore(float s);	//修改分数
	void display();	//显示信息
private://类的私有成员
	float score;	//学生成绩
	char *name;		//学生姓名
	char *Id;		//学生学号
};
#endif // STUDENT_H_INCLUDED

student.cpp

#include "student.h"
using namespace std;
#pragma warning(disable:4996)
student::student()//构造函数定义
{
	Id = new char[11];			//给变量分配存储空间
	strcpy(Id, "2016140282");	//给变量Id赋值
	name = new char[10];		//给变量分配存储空间
	strcpy(name, "高世皓");		//给变量name赋值
	score = 90;
}
student::student(char * pn, char * pid, float s)
{
	name = new char[strlen(pn) + 1];//分配存储空间
	strcpy(name, pn);
	Id = new char[strlen(pid) + 1];//分配存储空间
	strcpy(Id, pid);
	score = s;
}
student::~student()
{
	delete [] name;	//释放内存空间
	delete [] Id;	//释放内存空间
}
void student::chgName(char *pn)
{
	delete [] name;
	name = new char[strlen(pn) + 1];//给变量重新分配存储空间
	strcpy(name, pn);
}
void student::chgId(char *pid)
{
	delete [] Id;
	Id = new char[strlen(pid) + 1];//给变量重新分配存储空间
	strcpy(Id, pid);
}
void student::chgScore(float s)
{
	score = s;
}
void student::display()
{
	cout << "id:" << Id << endl;
	cout << "name:" << name << endl;
	cout << "score:" << score << endl;
}

main.cpp

#include "student.h"
int main()
{
	student s;		//定义对象s
	s.display();	//显示初始化值
	s.chgId("2016140283");
	s.chgName("张三");
	s.chgScore(87);
	s.display();
	
	student s1("李四", "2016140284", 89);
	s1.display();
	getchar();
	return 0;
}

<3>缺省参数的构造函数

构造函数中的参数可以指定默认值，此时如果在创建对象时不指定参数，编译系统将使用默认值来初始化数据成员。

#include <iostream>
using namespace std;
class point
{
private:
	int x;
	int y;
public:
	point(int vx = 0, int vy = 0)
	{
		x = vx;
		y = vy;
	}
	void display()
	{
		cout << "x = " << x << ",y = " << y << endl;
	}
};
int main()
{
	point p1;
	p1.display();
	point p2(10);
	p2.display();
	point p3(100, 100);
	p3.display();
	getchar();
}
/*
运行结果：
x = 0, y = 0 
x = 10, y = 0 
x =100, y = 100
*/

在函数所带的参数中,有一部分可以缺省,而一部分不可缺省,此时采取的规则是所有取缺省值的参数必须出现在不取缺省值的参数的右边，例:

point(int x,int y=0);   //正确
point(int x=0,int y);   //错误
void f(int i,int j,int k=10);   //正确
void xyout (char *str, int  x=-1,int y=-1);   //正确
void f(int i,int j=10,int k);   //错误

（3）构造函数的重载

构造函数可以像普通函数一样被重载，C++根据说明中的参数个数和类型选择合适的构造函数。若类 X 具有一个或多个构造函数，创建类 X 的对象时，C++会根据参数选择调用其中一个。构造函数可以使用默认参数，但谨防二义性。

class {
            //…
   public：
       x();         //不带参数的构造函数                
       x(int);         //只带一个整形参数的构造函数
       x(int,char);     
       x(float,char);
         //…
}；
//上面声明的四个构造函数，虽然名字相同，但它们所带的参数个数和类型均有所差别，这样系统在调用时可以找到合适的构造函数，而不致造成二义性。
int main()
{
  x a;                //定义x类的对象,并同时调用构造函数
  x b(1);
  x c(1,’c’);
  x d(3.5,’d’);
//…
}

（4）拷贝构造函数

<1>是特殊的构造函数，是用一个已存在的对象，来初始化一个同类的新对象；函数形参是对象的引用。

<2>格式：<类名> :: <拷贝初始化构造函数名> (const <类名> & <引用名>)

{

构造函数的函数体

}

<3>拷贝构造函数的两种定义形式：

系统产生：如果类中没有说明拷贝初始化构造函数，则编译系统自动生成一个具有上述形式的缺省拷贝初始化构造函数，作为该类的公有成员。系统具有为类产生一个缺省的拷贝构造函数的功能，我们只要使用即可，如下例。

#include <iostream>
using namespace std;
class point
{
private:
	int x;
	int y;
public:
	point(int vx, int vy)
	{
		x = vx;
		y = vy;
	}
	void print()
	{
		cout << "x = " << x << ",y = " << y << endl;
	}
};
int main()
{
	point p1(10, 20);
	point p2(p1);//也可以p2 = p1
	//此时调用的是系统缺省的拷贝构造函数。拷贝构造函数将p1对象的各个域的值都拷贝给了p2对象相应的域；因此p2对象的数据成员的值与p1对象的相同。
	p1.print();
	p2.print();
	getchar();
}

用户定义

#include <iostream>
using namespace std;
class point
{
private:
	int x;
	int y;
public:
	point(int vx, int vy);//带参数的构造函数
	void print();//输出
	point(const point &p);//声明拷贝构造函数
};
point::point(int vx, int vy)
{
	x = vx;
	y = vy;
}
void point::print()
{
	cout << "x = " << x << ",y = " << y << endl;
}
point::point(const point & p)//定义拷贝构造函数
{
	this -> x = p.x + 10;
	this -> y = p.y + 10;
}
int main()
{
	point p1(10, 20);
	point p2(p1);
	p1.print();
	p2.print();
	getchar();
}

注意：

1>定义并用其他类对象初始化一个对象时，拷贝构造函数被调用，如上例；

2>若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数，如例1；

3>当对象作为函数值返回时，拷贝构造函数被调用，如例2；
4> 含有指针成员的类，必须提供自己的拷贝构造函数和操作符函数。

5>例:下面情况不会调用拷贝构造函数

mytest c1（2,“hello”);
mytest c2;
c2=c1;
</pre><span style="font-size:18px; color:#ff0000">例1：</span></div><div><span style="font-size:18px"></span><pre code_snippet_id="1945638" snippet_file_name="blog_20161108_25_6622616" name="code" class="cpp">#include <iostream>
using namespace std;
 class point
 {
 private:
	 int x;
	 int y;
 public:
	 point(int vx, int vy);//带参数的构造函数
	 void print();//输出
	 point(const point &p);//自定义拷贝构造函数
 };
void point::print()
{
	cout << "x = " << x << ",y = " << y << endl;
}
point::point(const point & p)
{
	x = p.x + 11;
	y = p.y + 22;
}
void fun(point p)
{
	cout << "调用fun函数" << endl;
	cout << "p:";
	p.print();
}
point::point(int vx, int vy)
{
	cout << "调用带参数的构造函数" << endl;
	x = vx;
	y = vy;
}
int main()
{
	point p1(1, 2);//调用带参数的构造函数
	fun(p1);//调用拷贝构造函数
	cout << "p1:";
	p1.print();
	getchar();
}
/*
运行结果：
调用带参数的构造函数
调用fun函数
p:x= 12, y = 24
p1:x = 1, y = 2
*/

例2：

#include <iostream>
using namespace std;
 class point
 {
 private:
	 int x;
	 int y;
 public:
	 point(int vx, int vy);//带参数的构造函数
	 void print();//输出
	 point(const point &p);//自定义拷贝构造函数
 };
void point::print()
{
	cout << "x = " << x << ",y = " << y << endl;
}
point::point(const point & p)
{
	x = p.x + 13;
	y = p.y + 25;
}
point fun()
{
	point p1(1, 2);//调用带参数的构造函数
	cout << "调用fun函数" << endl;
	return p1;
}
point::point(int vx, int vy)
{
	cout << "调用带参数的构造函数" << endl;
	x = vx;
	y = vy;
}
int main()
{
	point p2(2,2);
	p2 = fun();
	cout << "p2:";
	p2.print();
	getchar();
}
/*
运行结果：
调用带参数的构造函数
调用带参数的构造函数
调用fun函数
p2:x = 14, y = 27
*/

3.析构函数

析构函数也是类的特殊成员函数，它的主要功能是对类中动态分配的内存进行释放，它在对象消失时自动调用；

析构函数的名称与其类名称相同，并在名称的前面加~；析构函数的函数体可写在类体内，也可以写在类体外；

析构函数没有参数和返回值；一个类中只可能定义一个析构函数，所以析构函数不能重载。
如果用到了动态内存,且变量不是数组,则析构函数的一般定义形式为:

~ 类名 ( )
{
delete 变量名;
}

如果变量是数组析构函数的一般形式为:

~ 类名 ( )
{
delete [ ] 变量名;
}

注意：用析构函数释放的空间是由构造函数分配，而不是由运算符new分配的。

例1：构造函数用于类型转换

//利用构造函数，由系统自动进行类型转换。
#include <iostream>
using namespace std;
#pragma warning(disable:4996)  
class A
{
private:
	char name[20];
public:
	A(char n[])//带参数的构造函数
	{
		strcpy((char *)name, n);
		cout << "调用带参数的构造函数" << endl;
	}
	void print()
	{
		cout << "name = " << name << endl;
	}
};
void fun(A a)
{
	a.print();
}
int main()
{
	char a[20] = "shgao";
	fun(a);//自动利用A类的构造函数把a 转换成：A 类
	getchar();
}
/*
	运行结果：
	name = shgao
*/