2.3实验二、三 构造函数与析构函数

第一篇：2.3实验二、三 构造函数与析构函数

南昌航空大学实验报告

年月日 课程名称：面向对象程序设计实验名称：构造函数与析构函数班级： XXXXXXX学生姓名：XXXXXX学号：指导教师评定：XX签名：XXXXX1、实验目的·理解类与对象的区别。

·学习掌握定义构造函数与析构函数的方法。

·学习把握默认构造函数的意义。

·了解类成员初始化，掌握构造与析构类成员的方式。

2、实验内容

(1)

创建一个Employee类，该类中用字符数组存放Employee的信息，如姓名、地址、市、省、及邮政编码；每个成员函数的定义放在类定义之外；成员函数包括改变姓名数据成员等；构造函数完成成员数据的初始化；用Display()函数将完整的对象数据打印出来；其中数据成员是保护的，成员函数是公共的。

#include

#include

#include

class Employee

{

public:

};Employee(char n[20],char a[50],char s[20],char sh[20],char p[6]);void ChangeName(char ch_name[20]);void Display();char name[20];char address[50];char shi[20];char sheng[20];char post[6];protected:

给出各个成员函数的具体实现

void main()

{

Employee em(“rer r34t3”,“5 West St.”,“Revere”,“CA”,“12290”);em.Display();em.ChangeName(“sdfesfefe”);

}

em.Display();

(2)设计一个表示矩形的类Rect，其矩形成员长float * Length ,宽float * Width为指针变量，设计相应成员函数，实现下列功能：

① 构造函数设置长和宽（默认为1）。

② 复制构造函数用老对象生成新对象。

③ set()函数设置长和宽（默认为0）。

④ 计算并返回长方形的周长。

⑤ 计算并返回长方形的面积。

⑥ 析构函数释放动态分配的长和宽。

编制主程序应用指针建立对象测试类。

#include

class Rect{

float *Length,*Width;

public:

Rect(float a=1,float b=1);

Rect(Rect &r);

void set(float a=0,float b=0);

float peri();

float area();

~Rect(){delete Length;delete Width;}

};

补充其余代码

//主函数

void main()

{ Rect r1(55.5,40);

cout<<“周长为：”<

cout<<“---------------------n”;

Rect *p=new Rect(r1);//思考:此处改为 Rect *p=new Rect;下一行的输出会是什么结果

cout<<“周长为：”<

peri()<<“面积为: ”<

area()<

p->set(20.5,13);

cout<<“周长为：”<

peri()<<“面积为: ”<

area()<

}

第二篇：二、类的设计,构造函数和析构函数

类是编程人员表达自定义数据类型的C++机制。它和C语言中的结构类似，C++类支持数据抽象和面向对象的程序设计，从某种意义上说，也就是数据类型的设计和实现。

一、类的设计

1.类的声明

class 类名

{

private://私有

...public://公有

...};

2.类的成员

一般在C++类中，所有定义的变量和函数都是类的成员。如果是变量，我们就叫它数据成员如果是函数，我们就叫它成员函数。

3.类成员的可见性

private和public访问控制符决定了成员的可见性。由一个访问控制符设定的可访问状态将一直持续到下一个访问控制符出现，或者类声明的结束。私有成员仅能被同一个类中的成员函数访问，公有成员既可以被同一类中的成员函数访问，也可以被其他已经实例化的类中函数访问。当然，这也有例外的情况，这是以后要讨论的友元函数。类中默认的数据类型是private，结构中的默认类型是public。一般情况下，变量都作为私有成员出现，函数都作为公有成员出现。

类中还有一种访问控制符protected，叫保护成员，以后再说明。

4.初始化

在声明一个类的对象时，可以用圆括号()包含一个初始化表。

看下面一个例子：

#include “iostream.h”

class Box

{

private:

int height,width,depth;//3个私有数据成员

public:

Box(int,int,int);

~Box();

int volume();//成员函数

};

Box::Box(int ht,int wd,int dp)

{

height=ht;

width=wd;

depth=dp;

}

Box::~Box()

{

//nothing

}

int Box::volume()

{

return height*width*depth;

}

int main()

{

Box thisbox(3,4,5);//声明一个类对象并初始化

cout<

return 0;

}

当一个类中没有private成员和protected成员时，也没有虚函数，并且不是从其他类中派生出来的，可以用{}来初始化。(以后再讲解)

5.内联函数

内联函数和普通函数的区别是：内联函数是在编译过程中展开的。通常内联函数必须简短。定义类的内联函数有两种方法：一种和C语言一样，在定义函数时使用关键字inline。如：

inline int Box::volume()

{

return height*width*depth;

}

还有一种方法就是直接在类声明的内部定义函数体，而不是仅仅给出一个函数原型。我们把上面的函数简化一下：

#include “iostream.h”

class Box

{

private:

int height,width,depth;

public:

Box(int ht,int wd,int dp)

{

height=ht;

width=wd;

depth=dp;

}

~Box();

int volume()

{

return height*width*depth;

}

};

int main()

{

Box thisbox(3,4,5);//声明一个类对象并初始化

cout<

return 0;

}

这样，两个函数都默认为内联函数了。

二、构造函数

什么是构造函数？通俗的讲，在类中，函数名和类名相同的函数称为构造函数。上面的Box()函数就是构造函数。C++允许同名函数，也就允许在一个类中有多个构造函数。如果一个都没有，编译器将为该类产生一个默认的构造函数，这个构造函数可能会完成一些工作，也可能什么都不做。

绝对不能指定构造函数的类型，即使是void型都不可以。实际上构造函数默认为void型。

当一个类的对象进入作用域时，系统会为其数据成员分配足够的内存，但是系统不一定将其初始化。和内部数据类型对象一样，外部对象的数据成员总是初始化为0。局部对象不会被初始化。构造函数就是被用来进行初始化工作的。当自动类型的类对象离开其作用域时，所站用的内存将释放回系统。

看上面的例子，构造函数Box()函数接受三个整型擦黑素，并把他们赋值给立方体对象的数据成员。

如果构造函数没有参数，那么声明对象时也不需要括号。

1.使用默认参数的构造函数

当在声明类对象时，如果没有指定参数，则使用默认参数来初始化对象。

#include “iostream.h”

class Box

{

private:

int height,width,depth;

public:

Box(int ht=2,int wd=3,int dp=4)

{

height=ht;

width=wd;

depth=dp;

}

~Box();

int volume()

{

return height*width*depth;

}

};

int main()

{

Box thisbox(3,4,5);//初始化

Box defaulbox;//使用默认参数

cout<

cout<

4return 0;

}

2.默认构造函数

没有参数或者参数都是默认值的构造函数称为默认构造函数。如果你不提供构造函数，编译器会自动产生一个公共的默认构造函数，这个构造函数什么都不做。如果至少提供一个构造函数，则编译器就不会产生默认构造函数。

3.重载构造函数

一个类中可以有多个构造函数。这些构造函数必须具有不同的参数表。在一个类中需要接受不同初始化值时，就需要编写多个构造函数，但有时候只需要一个不带初始值的空的Box对象。

#include “iostream.h”

class Box

{

private:

int height,width,depth;

public:

Box(){ //nothing }

Box(int ht=2,int wd=3,int dp=4)

{

height=ht;

width=wd;

depth=dp;

}

~Box();

int volume()

{

return height*width*depth;

}

};

int main()

{

Box thisbox(3,4,5);//初始化

Box otherbox;

otherbox=thisbox;

cout<

return 0;

}

这两个构造函数一个没有初始化值，一个有。当没有初始化值时，程序使用默认值，即2，3，4。

但是这样的程序是不好的。它允许使用初始化过的和没有初始化过的Box对象，但它没有考虑当thisbox给otherbox赋值失败后，volume()该返回什么。较好的方法是，没有参数表的构造函数也把默认值赋值给对象。

class Box

{

int height,width,depth;

public:

Box()

{

height=0;width=0;depth=0;

}

Box(int ht,int wd,int dp)

{

height=ht;width=wd;depth=dp;

}

int volume()

{

return height*width*depth;

}

};

这还不是最好的方法，更好的方法是使用默认参数，根本不需要不带参数的构造函数。

class Box

{

int height,width,depth;

public:

Box(int ht=0,int wd=0,int dp=0)

{

height=ht;width=wd;depth=dp;

}

int volume()

{

return height*width*depth;

}

};

三、析构函数

当一个类的对象离开作用域时，析构函数将被调用(系统自动调用)。析构函数的名字和类名一样，不过要在前面加上 ~。对一个类来说，只能允许一个析构函数，析构函数不能有参数，并且也没有返回值。析构函数的作用是完成一个清理工作，如释放从堆中分配的内存。

我们也可以只给出析构函数的形式，而不给出起具体函数体，其效果是一样的，如上面的例子。但在有些情况下，析构函数又是必需的。如在类中从堆中分配了内存，则必须在析构函数中释放

第三篇：关于C++构造函数与析构函数的说明

关于构造函数与析构函数的说明

 构造函数、析构函数一定有。

 子类构造函数（开始时）一定会调用父类构造函数。 子类析构函数（结束时）一定会调用父类析构函数。

1.如果没有定义构造函数，C++会自动添加默认构造函数（即无参的构造函数，只负责分配空间，不负责数据的初始化值）。

2.如果有定义的构造函数（不管有参的还是无参的），C++不会再自动添加默认构造函数。

3.子类的构造函数一定会调用父类构造函数，在不指定的情况下，自动调用无参的构造函数。

4.如果没有定义析构函数，C++会自动添加默认析构函数。

5.子类析构函数结束时会自动调用父类析构函数。

第四篇：类的构造函数 析构函数与赋值函数

类的构造函数 析构函数与赋值函数

构造函数 析构函数与赋值函数是每个类最基本的函数。它们太普通以致让人容易麻痹大意，其实这些貌似简单的函数就象没有顶盖的下水道那样危险。

每个类只有一个析构函数和一个赋值函数，但可以有多个构造函数（包含一个拷贝构造函数，其它的称为普通构造函数）。对于任意一个类A，如果不想编写上述函数，C++编译器将自动为A产生四个缺省的函数，如

A(void);// 缺省的无参数构造函数

A(const A &a);// 缺省的拷贝构造函数

~A(void);// 缺省的析构函数

A & operate =(const A &a);// 缺省的赋值函数

这不禁让人疑惑，既然能自动生成函数，为什么还要程序员编写？

原因如下：

（1）如果使用“缺省的无参数构造函数”和“缺省的析构函数”，等于放弃了自主“初始化”和“清除”的机会，C++发明人Stroustrup的好心好意白费了。

（2）“缺省的拷贝构造函数”和“缺省的赋值函数”均采用“位拷贝”而非“值拷贝”的方式来实现，倘若类中含有指针变量，这两个函数注定将出错。

对于那些没有吃够苦头的C++程序员，如果他说编写构造函数 析构函数与赋值函数很容易，可以不用动脑筋，表明他的认识还比较肤浅，水平有待于提高。

本章以类String的设计与实现为例，深入阐述被很多教科书忽视了的道理。String的结构如下：

class String

{

public:

String(const char *str = NULL);// 普通构造函数

String(const String &other);// 拷贝构造函数

~ String(void);// 析构函数

String & operate =(const String &other);// 赋值函数private:

char*m_data;// 用于保存字符串

};

第五篇：构造函数-析构函数的调用顺序

C++继承中构造函数、析构函数调用顺序及虚函数的动态绑定

昨天面试被问到这些，惭愧的很，居然搞混了，悔恨了一把。决定要彻底搞清楚。也算是有所收获。

首先说说构造函数，大家都知道构造函数里就可以调用成员变量，而继承中子类是把基类的成员变成自己的成员，那么也就是说子类在构造函数里就可以调用基类的成员了，这就说明创建子类的时候必须先调用基类的构造函数，只有这样子类才能在构造函数里使用基类的成员，所以是创建子类时先调用基类的构造函数然后再调用自己的构造函数。通俗点说，你要用某些物品，但这些物品你没办法自己生产，自然就要等别人生产出来，你才能拿来用。

接着就是析构函数了，上面说到子类是将基类的成员变成自己的成员，那么基类就会只存在子类中直到子类调用析构函数后。做个假设：假如在基类的析构函数调用比子类的先，这样会发生什么事呢？类成员终止了，而类本身却还在，但是在类存在的情况下，类成员就应该还存在的，这不就产生矛盾了吗？所以子类是调用自身的析构函数再调用基类的析构函数。

现在到了虚函数了，virtual主要作用是在多态方面，而C++的多态最主要的是类的动态绑定，动态绑定则是指将子类的指针或引用转换成基类对象，基类对象就可以动态判断调用哪个子类成员函数。这就说明在没有子类指针或引用转换为基类对象的话，virtual没有存在意义（纯虚函数除外），也就是有没有virtual都是调用其自身的成员函数。通过这些分析，对于virtual就有了眉目了。当子类指针或引用转换为基类时，若基类中有用virtual定义的函数，被子类重写后，此基类对象就会根据子类调用子类中的重写后的函数，而不是基类中的函数；反之，若是基类中没有用virtual定义，则不管基类被赋值的是哪个子类的值，调用的都是基类的成员函数（当然指的是子类重载的基类函数，不然就算要调用子类特有的成员函数也会编译不过）。