C++类的问题，构造函数和析构函数_百度知道
C++类的问题，构造函数和析构函数
&;&lt: A a: D( int main(int argc){ C* pc = new D(1,&}
~C(){cout&,int k);& };& BA &&lt,C(k){cout&lt:a(i);~D &
return 0;} ~A(){}};D &B &C &;}
~B(){}}; class B{ &lt,2,3): B(int j){cout&&&&lt: public C{ ;~C &; class C{ &quot: C(int k){cout&;&} }}; class D ,b(j);} ~D(){cout&ltclass A{public: A(int i){cout&lt
结果是什么？
提问者采纳
所以最后输出，由于他是以初始化表的形式出现的;}&nbsp://h; -------&k){cout&&;&的构造函数A(int&&quot.jpg" />new&nbsp：/zhidao/wh%3D600%2C800/sign=e26e25dbfef8f3cdd03b/9a504fc2d5628535caa2b0a7ef630b，同时D继承自C;A&输出字符Bcout& &nbsp,2.hiphotos：C&nbsp://h;&quot,C(k){cout&}依次进行初始化C(k)&B的构造函数B(int&nbsp,b(j),int&nbsp:& &B&nbsp：D(int& -------&gt.baidu，调用类&合在一起就是;&}&}&Ca(i)& &D&nbsp.&/zhidao/wh%3D450%2C600/sign=ecb194adfde0e90bb2a488f4/9a504fc2d5628535caa2b0a7ef630b，delete应该调C类的析构函数&nbsp.jpg" esrc="~C&&*pc.<img class="ikqb_img" src="调用类&;------&B& -------&-------------------------------------------------------&输出字符&&Ab(j)&输出字符&i;D&nbsp,int&&A&执行D的构造函数://h;&D&&C的构造函数C(int&j){cout& &-----& &&quot
为什么没有调用D的析构函数？
就是因为声明的问题
C *pc，他实际上不管具体指向的是基类对象还是派生类对象，在delete时，只会去调声明时的的类的析构函数，所以调C，不调D的析构函数。
提问者评价
谢谢你帮我大忙了
其他类似问题
按默认排序
其他1条回答
先构造父类，这两个的构造顺序、最后构造D4： C A B D ~C1正确顺序、然后根据参数构造A和B，故先构造C。3。先定义a，是根据在D中a和b定义的顺序定的，输出C2，D是C的子类、释放空间，故先构造A
那为什么没有调用派生类D的析构函数呢？他析构的顺序不应该是与构造函数调用的顺序相反嘛？
因为你在主函数里创建的C类的对象，析构肯定调用C的析构函数
析构函数的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁页面导航：
→ 正文内容 c++类构造函数
c++类构造函数详解
这篇文章主要介绍了c++类构造函数示例,需要的朋友可以参考下
代码如下://一、 构造函数是干什么的
/*&& 类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数-&由构造函数完成成员的初始化工作&&&& eg: Counter c1;
&&&& 编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象，初始化之后c1的m_value值设置为0
&&&& 故：构造函数的作用：初始化对象的数据成员。*/
&&&&& class Counter&&&&&& {&&&&& public:&&&&&& // 类Counter的构造函数，以类名作为函数名，无返回类型&&&&& Counter(){ &&&&& m_value = 0;&&&&& }
&&&&& private:&&&&& int m_& // 类私有的数据成员&&&&& }
//二、 构造函数的种类
#include &iostream&
class Complex{private :&&& double m_&&& double m_
//*无参数构造函数
// 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做// 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
&&& Complex(void)&&& {&& m_real = 0.0;&&&&&&& m_imag = 0.0;&&& }
//*一般构造函数（也称重载构造函数）
//一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
//例如：你还可以写一个 Complex(int num)的构造函数出来，创建对象时根据传入的参数不同调用不同的构造函数
&&& Complex(double real, double imag)&&& {&& m_real =&&&&&&& m_imag =&&& }
//*复制构造函数（也称为拷贝构造函数）
//复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
//若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因在有关 “浅拷贝”、“深拷贝”的文章中论述
&&& Complex(const Complex & c)&&& {&& // 将对象c中的数据成员值复制过来&&&&&&& m_real = c.m_&&&&&&& m_imag = c.m_&&& }
//*类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象，需要注意的一点是，这个其实就是一般的构造函数，但是对于出现这种单参数的构造函数，C++会默认将参数对应的类型转换为该类类型，
//有时候这种隐私的转换是我们所不想要的，所以需要使用explicit来限制这种转换。
//例如：下面将根据一个double类型的对象创建了一个Complex对象
&&& Complex(double r)&&& {&& m_real =&&&&&&& m_imag = 0.0;&&& }
// 等号运算符重载（也叫赋值构造函数）
// 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建。
// 若没有显示的写 =运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
&&& Complex &operator=(const Complex &rhs )
&&& {&& // 首先检测等号右边的是否就是左边的对象本身，若是本对象本身,则直接返回&&&&&&& if ( this == &rhs )&&&&&&& {&& return *&&&&&&& }
&&&&&&& // 复制等号右边的成员到左边的对象中&&&&&&& this-&m_real = rhs.m_&&&&&&& this-&m_imag = rhs.m_
&&&&&&& // 把等号左边的对象再次传出,目的是为了支持连等 eg:a=b=c 系统首先运行 b=c 然后运行 a=(b=c的返回值,这里应该是复制c值后的b对象)&&&&&&& return *&&& }};
//三、使用上面定义的类对象来说明各个构造函数的用法：
int main(){&& &&& // 调用了无参构造函数，数据成员初值被赋值为0.0&&& Complex c1,c2;
&&& // 调用一般构造函数，数据成员初值分别被赋为指定值&&& Complex c3(1.0,2.5);
&&& // 当然，也可以使用下面的形式&&& // Complex c3 = Complex(1.0,2.5);
&&& //& 把c3的数据成员的值赋值给事先被创建的对象c1&&& //& 由于c1已经事先被创建，故此处不会调用任何构造函数&&& //& 只会调用 = 号运算符重载函数&&& c1 = c3;&
&&& //& 调用类型转换构造函数&&& //& 系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c2&&& c2 = 5.2;&
&&& // 调用拷贝构造函数( 有下面两种调用方式)
&&& Complex c5(c3);&&& Complex c4 = c3;
&&& // 注意和 =运算符重载的区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2&&& // 这一点特别重要，这儿是初始化，不是赋值。&&& // 其实这儿就涉及了C++中的两种初始化的方式：复制初始化和赋值初始化。&&& // 其中c5采用的是复制初始化，而c4采用的是赋值初始化，这两种方式都是要调用拷贝构造函数的。
您可能感兴趣的文章:
上一篇：下一篇：
最 近 更 新
热 点 排 行
12345678910c++类的构造函数详解
一、构造函数是干什么的
// 类Dog的构造函数
// 特点：以类名作为函数名，无返回类型
weight = 0;
// 数据成员
该类对象被创建时，编译对象分配内存空间，并自动调用该构造函数-&由构造函数完成成员的初始化工作
int main()
编译系统为对象dd的每个数据成员(weight)分配内存空间，并调用构造函数Dog( )自动地初始化对象dd的weight值设置为0
构造函数的作用：初始化对象的数据成员。
二、 构造函数的种类
// 无参数构造函数
// 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
// 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
height= 0.0;
width=0.0;
// 一般构造函数（也称重载构造函数）
// 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
// 例如：你还可以写一个 Dog( int num)的构造函数出来
// 创建对象时根据传入的参数不同调用不同的构造函数
Dog(double a, double b)
// 复制构造函数（也称为拷贝构造函数）
// 复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
// 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 &浅拷贝& 、&深拷贝&的文章论述
Dog(const Dog & c)
//将对象c中的数据成员值复制过来
height = c.
width = c.
// 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
// 例如：下面将根据一个double类型的对象创建了一个Dog对象
Dog::Dog(double r)
width = 0.0;
// 等号运算符重载
// 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
// 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
Dog &operator=( const Dog&rhs )
//首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
if ( this ==&rhs )
//复制等号右边的成员到左边的对象中
this-&height= rhs.
this-&width= rhs.
//把等号左边的对象再次传出
//目的是为了支持连等 eg: a=b=c 系统首先运行 b=c
//然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
下面使用上面定义的类对象来说明各个构造函数的用法：
void main()
// 调用了无参构造函数，数据成员初值被赋为0.0
Dog c1，c2;
// 调用一般构造函数，数据成员初值被赋为指定值
Dog c3(1.0,2.5);
// 也可以使用下面的形式
Dog c3 = Dog(1.0,2.5);
// 把c3的数据成员的值赋值给c1
// 由于c1已经事先被创建，故此处不会调用任何构造函数
// 只会调用 = 号运算符重载函数
// 调用类型转换构造函数
// 系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
// 调用拷贝构造函数( 有下面两种调用方式)
Dog c5(c2);
Dog c4 = c2; // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
您对本文章有什么意见或着疑问吗？请到您的关注和建议是我们前行的参考和动力&&
您的浏览器不支持嵌入式框架，或者当前配置为不显示嵌入式框架。【c++类怎么构造class complex c=4.5;】-突袭网
21:35:55【 转载互联网】 作者： &&|&责编：李强
&&& &为了解决用户可能碰到关于"c++类怎么构造class complex c=4.5;"相关的问题，突袭网经过收集整理为用户提供相关的解决办法，请注意，解决办法仅供参考，不代表本网同意其意见,如有任何问题请与本网联系。"c++类怎么构造class complex c=4.5;"相关的详细问题如下:定义一个复数类Complex，使得下面的代码能够工作 Com畅甫扳晃殖浩帮彤爆廓plex c1(3,5); &#47;&#47; 用复数3+5i初始化c1Complex c2 = 4.5; &#47;&#47; 用实参4.5初始化c2 c1.add(c2); &#47;&#47; 将c1与c2相加，结果保存在c1中 c1.show(); &#47;&#47; 将c1输出（这时结果应该是7.5+5i）===========突袭网收集的解决方案如下===========
解决方案1：结构和类在使用上没有区别，唯一的区别是在内存里的储存方式。 结构将会被执行库分配存在堆栈上，而类将会被执行库分配存储在引用托管堆中。 也就是C++的结构是被执行库当作用户自定义的值类型对待的，而类是被当作引用类型对待。 在需要访问快、且几乎不做运算的那些数据应该作为结构，而需要做很多运算的那些数据应该作为类。 int是.NET程序集的内部值类型，对应于Int32。因该是个结构才对，不过不能确定，毕畅甫扳晃殖浩帮彤爆廓竟计算机处理的是计算机语言的形式化语意。但可以确定int是一个派生于object的密封对象。解决方案2：与我想问的无关。。。今天看啥 热点：
下面讲如何使用C++类构造函数，所谓C++类是定义同一类所有对象的变量和方法的蓝图或原型，C++类体内的成员是需要开辟动态开辟堆内存的,如果我们不自定义拷贝构造函数而让系统自己处理。
我们已经学习过了类的构造函数和析构函数的相关知识，对于普通类型的对象来说，他们之间的复制是很简单的，例如： 自己定义的类的对象同样是对象，谁也不能阻止我们用以下的方式进行复制,例如：#include&&& &using&namespace&&& &&& &class&Test&& &{&& &public:&& &&&&&Test(int&temp)&& &&&&&{&& &&&&&&&&&p1=temp;&& &&&&&}&& &protected:&& &&&&&int&p1;&& &&& &};&& &&& &void&main()&& &{&& &&&&&Test&a(99);&& &&&&&Test&b=a;&& &}&
普通对象和类对象同为对象，他们之间的特性有相似之处也有不同之处，C++类对象内部存在成员变量，而普通对象是没有的，当同样的复制方法发生在不同的对象上的时候，那么系统对他们进行的操作也是不一样的，就C++类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。
在上面的代码中,我们并没有看到拷贝构造函数，同样完成了复制工作，这又是为什么呢？因为当一个类没有自定义的拷贝构造函数的时候系统会自动提供一个默认的拷贝构造函数，来完成复制工作。
下面，我们为了说明情况，就普通情况而言(以上面的代码为例)，我们来自己定义一个与系统默认拷贝构造函数一样的拷贝构造函数，看看它的内部是如何工作的！
代码如下：#include&&& &using&namespace&&& &&& &class&Test&& &{&& &public:&& &&&&&Test(int&temp)&& &&&&&{&& &&&&&&&&&p1=temp;&& &&&&&}&& &&&&&Test(Test&&c_t)//这里就是自定义的拷贝构造函数&& &&&&&{&& &&&&&&&&&cout"进入copy构造函数";&& &&&&&&&&&p1=c_t.p1;//这句如果去掉就不能完成复制工作了,此句复制过程的核心语句&& &&&&&}&&&
上面代码中的Test(Test &c_t)就是我们自定义的拷贝构造函数，拷贝构造函数的名称必须与C++类名称一致，函数的形式参数是本C++类型的一个引用变量,且必须是引用。 当用一个已经初始化过了的自定义C++类类型对象去初始化另一个新构造的对象的时候。
拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候系统将会提供给一个默认的拷贝构造函数来完成这个过程。上面代码的复制核心语句就是通过Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。
如果取掉这句代码，那么b对象的p1属性将得到一个未知的随机值；就上面的代码情况而言，很多人会问到，既然系统会自动提供一个默认的拷贝构造函数来处理复制，那么我们没有意义要去自定义拷贝构造函数呀。
短时间内玩转C++语言
怎样定义C++中的C++变量？
浅析定义C++数据类型
C++设计规则说明
C++Test怎样自动生成桩函数
对，就普通情况而言这的确是没有必要的，但在某写状况下，C++类体内的成员是需要开辟动态开辟堆内存的,如果我们不自定义拷贝构造函数而让系统自己处理，那么就会导致堆内存的所属权产生混乱，试想一下，已经开辟的一端堆地址原来是属于对象a的。
由于复制过程发生，b对象取得是a已经开辟的堆地址，一旦程序产生析构，释放堆的时候，计算机是不可能清楚这段地址是真正属于谁的，当连续发生两次析构的时候就出现了运行错误。
相关搜索：
相关阅读：
相关频道：
&&&&&&&&&&&&&&&&
C++教程最近更新}