原文链接:http://blog.chinaunix.net/uid-10666692-id-1759590.html
分类: C/C++
第一段:
C++ 和 C#/java 有很多区别,其中最大的区别当数对内存的管理。
C++ 中,类的使用者决定了类的实例内存会如何分配,分配在堆上还是栈上。我们先看一段例子程序:
#include "stdio.h"
class Demo{
public :
int i;
char* objName;
Demo(){
objName = "Default object.";
printf("%s, objName = %s\r\n", "Enter Demo default ctor. method.", objName);
i = 1000;
}
Demo(int ival, char* name){
printf("%s,i = %d, objName = %s\r\n", "Enter Demo(int ival) ctor method", ival, name);
i = ival;
objName = name;
}
Demo(const Demo& d){
printf("%s\r\n", "Enter Demo copy ctor method.");
i = d.i;
objName = "copied d";
}
~Demo(){
printf("%s, i = %d, objName = %s\r\n", "Enter Demo dector. method" , i, objName);
}
};
Demo& testMethod0(){
printf("%s\r\n", "Enter testMethod0.");
Demo d(0, "d in testMethod0");
printf("%s\r\n", "Exit testMethod0.");
return d;
}
Demo testMethod1(){
printf("%s\r\n", "Enter testMethod1.");
Demo d(1, "d in testMethod1");
printf("%s\r\n", "Exit testMethod1.");
return d;
}
Demo* testMethod2(){
printf("%s\r\n", "Enter testMethod2.");
Demo *d = new Demo(2, "d in testMethod2");
printf("%s\r\n", "Exit testMethod2.");
return d;
}
int main(int argc, _TCHAR* argv[])
{
Demo d;
d = testMethod1();
Demo& d1 = testMethod0();
Demo d2(999, "d1");
Demo* d3 = testMethod2();
printf("d.i = %d\r\n", d.i);
printf("d1.i = %d\r\n", d1.i);
printf("d2.i = %d\r\n", d2.i);
printf("d3.i = %d\r\n", d3->i);
delete d3;
return 0;
}
Output :
Enter Demo default ctor. method., objName = Default object.
Enter testMethod1.
Enter Demo(int ival) ctor method,i = 1, objName = d in testMethod1
Exit testMethod1.
Enter Demo copy ctor method.
Enter Demo dector. method, i = 1, objName = d in testMethod1
Enter Demo dector. method, i = 1, objName = copied d
Enter testMethod0.
Enter Demo(int ival) ctor method,i = 0, objName = d in testMethod0
Exit testMethod0.
Enter Demo dector. method, i = 0, objName = d in testMethod0
Enter Demo(int ival) ctor method,i = 999, objName = d1
Enter testMethod2
Enter Demo(int ival) ctor method,i = 2, objName = d in testMethod2
Exit testMethod2.
d.i = 1
d1.i = -2
d2.i = 999
d3.i = 2
Enter Demo dector. method, i = 2, objName = d in testMethod2
Enter Demo dector. method, i = 999, objName = d1
Enter Demo dector. method, i = 1, objName = copied d
与 C# 不同,在 C++ 中,对象声明的时候就已经执行了构造函数,比如上面例子的 main 函数中的第一行, Demo d ,从屏幕上的输出来看,这个时候 Demo class 的默认构造函数会被调用。
接下来的一行代码调用,引出了很有趣的情况,当然也隐藏着不小的问题。这行代码造成了一次构造函数调用,一次拷贝构造函数调用和两次析构函数调用。让我们来具体分析一下:第一次调用构造函数很容易理解,因为在testMethod1 中我们声明了 Demo d(0) ,退出 testMethod1 ,函数的返回值要赋值给变量 d2 ,这个时候, d2 被拷贝构造函数重新构造了一次。接着 testMethod1 中构造的局部变量被析构,然后,居然拷贝构造函数构造的对象也被析构?等等,看完所有输出,我们发现, objName = copied d 的对象被析构两次,而 objName = Default obj 的对象被构造出之后没有被析构,这里隐藏了很严重的问题,有可能导致内存泄漏、句柄不能被正确关闭等等。另外,拷贝构造函数的执行可能导致潜在的效率问题,考虑一个包含巨大矩阵的对象, copy 这个对象会怎么样?
接下来的一行代码, testMethod0 返回一个对象的引用,当然不会导致拷贝构造函数被调用,但是,这样也是有问题的,在函数中声明的局部变量在函数执行完成的时候会被析构,那么直接返回局部变量就可能会出现问题。testMethod0 退出以后,他内部的 Demo 对象就会自动析构,外面对它的引用当然也无法指向正确的对象了,所以后面程序打印 d.i 的时候,输出了一个莫名其妙的 -2 。
效率最好的方法当数返回指针了,它不会导致对象复制,如果使用得当,也不会导致内存泄漏或者句柄泄漏。 testMethod2 演示了这种情况,当然,你需要手工删除在 testMethod2 中创建的对象。
不过我的意见是:“objName = copied d 的对象被析构两次,objName = Default obj 的对象被构造出之后没有被析构”是不对的,对于d = testMethod1();这条语句,d对象还是原来的内存空间,只是它执行了编译器默认的赋值操作,由于这个默认的赋值只是位拷贝(也就是成员的逐个赋值),将指针的值也是简单复制,于是这两个对象的objName指向相同的字符串地址。
于是d对象析构的时候,打印的objName是“objName = copied d”。出现内存泄漏的原因是你的Demo类中的objName,但又没有提供相应完整的拷贝,赋值,析构。
A(void); // 缺省的无参数构造函数
A(const A &a); // 缺省的拷贝构造函数
~A(void); // 缺省的析构函数
A & operate =(const A &a); // 缺省的赋值函数
有几个需要注意的内容:
@ 构造函数与析构函数的另一个特别之处是没有返回值类型
@ 构造从类层次的最顶层的基类开始,在每一层中,首先调用基类的构造函数,然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行,在析构的时候,最低层的派生类的析构函数最开始被调用,然后调用每个基类的析构函数。
@ “缺省的拷贝构造函数”和“缺省的赋值函数”均采用“位拷贝”而非“值拷贝”的方式来实现,倘若类中含有指针变量,这两个函数注定将出错
下面通过例子进一步说明,
1.构造函数的初始化表
设存在两个类:
{
…
A( void ); // 无参数构造函数
A( const A & other); // 拷贝构造函数
A & operate = ( const A & other); // 赋值函数
virtual ~ A( void ); // 析构函数
};
class B
{
public :
B( const A & a); // B的构造函数
private :
A m_a; // 成员对象
};
下面面是B的构造函数的2个实现,其中第一个的类B的构造函数在其初始化表里调用了类A的拷贝构造函数,从而将成员对象m_a初始化;而第二个的B的构造函数在函数体内用赋值的方式将成员对象m_a初始化。我们看到的只是一条赋值语句,但实际上B的构造函数干了两件事:先暗地里创建m_a对象(调用了A的无参数构造函数),再调用类A的赋值函数,将参数a赋给m_a。
: m_a(a)
{
…
}
B::B( const A & a)
{
m_a = a;
…
}
2.拷贝函数和构造函数的区别
拷贝构造函数是在对象被创建时调用的,而赋值函数只能被已经存在了的对象调用。
String a(“hello”);
String b(“world”);
String c = a; // 调用了拷贝构造函数,最好写成 c(a);
c = b; // 调用了赋值函数
本例中第三个语句的风格较差,宜改写成String c(a) 以区别于第四个语句。
如果我们实在不想编写拷贝构造函数和赋值函数,又不允许别人使用编译器生成的缺省函数,可以将拷贝构造函数和赋值函数声明为私有函数,不用编写代码。
3.析构函数与虚析构函数
基类的构造函数、析构函数、赋值函数都不能被派生类继承。如果类之间存在继承关系,在编写上述基本函数时应注意以下事项:
@ 派生类的构造函数应在其初始化表里调用基类的构造函数
@ 基类与派生类的析构函数应该为虚(即加virtual关键字)
class Base
{
public :
virtual ~ Base() { cout << " ~Base " << endl ; }
};
class Derived : public Base
{
public :
virtual ~ Derived() { cout << " ~Derived " << endl ; }
};
void main( void )
{
Base * pB = new Derived; // upcast
delete pB;
}
输出结果为:
~Derived
~Base
如果析构函数不为虚,那么输出结果为
~Base
--------------------------------------------------------------------------------------------------------------------
#include #include class Person { private: char* _name; public: Person() { _name = new char[256]; } void SetName(const char* name) { if(strlen(name) + 1 < 256) strcpy(_name,name); } void PrintName() { printf("%s\n",_name); } }; int main() { // 创建对象的第一个实例并赋于名字为John Person p1; p1.SetName("John"); p1.PrintName(); //通过复制p1引用的对象创建另一个对象 Person p2(p1); p2.SetName("Alice"); p2.PrintName(); //现在再输出p1的名字 p1.PrintName(); scanf("q"); return 0; } |
这里的类Person有一个指向在堆上分配的字符数组的指针。当构造Person对象时,它创建该字符数组并把它的位置存放到变量_name中。
但是当你创建Person 对象 p2 时,p2的成员用p1的成员初始化。因而,p1的 _name与p2的 _name指向相同的堆对象。如在上例中看到的,调用p2.SetName将改变由这两个类共享的值。所以,当第二次调用p1.PrintName,打印结果是"Alice"。
所以,这不是我们复制对象所期望的结果,而且还会导致堆崩溃的问题。请再考虑某个函数删除了该数组而p1又要调用该函数的情况?下面,当p2调用PrintName时,它将尽量存取实际上不是在堆上的对象。这种情况下产生的结果往往是难以预料的。
C++允许我们通过定义拷贝构造函数来克服这类问题。在我们每次通过复制另一个对象来初始化一个对象时,拷贝构造函数都被执行。你可以在拷贝构造函数中覆盖掉缺省的成员函数的复制行为。
所以,我们的类Person应该修改如下:
class Person |
这里类Person中的拷贝构造函数保证了它初始化一个新的数组,为在复制时产生的每一个对象实例所用。这就避免了前面我们提到的问题。
int a = 10;
int b =a;
自己定义的类的对象同样是对象,谁也不能阻止我们用以下的方式进行复制,例如:
|
普通对象和类对象同为对象,他们之间的特性有相似之处也有不同之处,类对象内部存在成员变量,而普通对象是没有的,当同样的复制方法发生在不同的对象上的时候,那么系统对他们进行的操作也是不一样的,就类对象而言,相同类型的类对象是通过拷贝构造函数来完成整个复制过程的,在上面的代码中,我们并没有看到拷贝构造函数,同样完成了复制工作,这又是为什么呢?因为当一个类没有自定义的拷贝构造函数的时候系统会自动提供一个默认的拷贝构造函数,来完成复制工作。
下面,我们为了说明情况,就普通情况而言(以上面的代码为例),我们来自己定义一个与系统默认拷贝构造函数一样的拷贝构造函数,看看它的内部是如何工作的!
代码如下:
|
上面代码中的Test(Test &c_t)就是我们自定义的拷贝构造函数,拷贝构造函数的名称必须与类名称一致,函数的形式参数是本类型的一个引用变量,且必须是引用。
当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就会被自动调用,如果你没有自定义拷贝构造函数的时候系统将会提供给一个默认的拷贝构造函数来完成这个过程,上面代码的复制核心语句就是通过Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。如果取掉这句代码,那么b对象的p1属性将得到一个未知的随机值;
下面我们来讨论一下关于浅拷贝和深拷贝的问题。
就上面的代码情况而言,很多人会问到,既然系统会自动提供一个默认的拷贝构造函数来处理复制,那么我们没有意义要去自定义拷贝构造函数呀,对,就普通情况而言这的确是没有必要的,但在某写状况下,类体内的成员是需要开辟动态开辟堆内存的,如果我们不自定义拷贝构造函数而让系统自己处理,那么就会导致堆内存的所属权产生混乱,试想一下,已经开辟的一端堆地址原来是属于对象a的,由于复制过程发生,b对象取得是a已经开辟的堆地址,一旦程序产生析构,释放堆的时候,计算机是不可能清楚这段地址是真正属于谁的,当连续发生两次析构的时候就出现了运行错误。
为了更详细的说明问题,请看如下的代码。
|
上面代码就演示了深拷贝的问题,对对象b的cname属性采取了新开辟内存的方式避免了内存归属不清所导致析构释放空间时候的错误,最后我必须提一下,对于上面的程序我的解释并不多,就是希望读者本身运行程序观察变化,进而深刻理解。
拷贝和浅拷贝的定义可以简单理解成:如果一个类拥有资源(堆,或者是其它系统资源),当这个类的对象发生复制过程的时候,这个过程就可以叫做深拷贝,反之对象存在资源但复制过程并未复制资源的情况视为浅拷贝。
浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错,这点尤其需要注意!
以前我们的教程中讨论过函数返回对象产生临时变量的问题,接下来我们来看一下在函数中返回自定义类型对象是否也遵循此规则产生临时对象!
先运行下列代码:
|
从上面的代码运行结果可以看出,程序一共载入过析构函数三次,证明了由函数返回自定义类型对象同样会产生临时变量,事实上对象a得到的就是这个临时Internet类类型对象temp的值。
这一下节的内容我们来说一下无名对象。
利用无名对象初始化对象系统不会不调用拷贝构造函数。
那么什么又是无名对象呢?
很简单,如果在上面程序的main函数中有:
Internet ("中国软件开发实验室","www.cndev-lab.com");
这样的一句语句就会产生一个无名对象,无名对象会调用构造函数但利用无名对象初始化对象系统不会不调用拷贝构造函数!
下面三段代码是很见到的三种利用无名对象初始化对象的例子。
|
上面代码的运行结果有点“出人意料”,从思维逻辑上说,当无名对象创建了后,是应该调用自定义拷贝构造函数,或者是默认拷贝构造函数来完成复制过程的,但事实上系统并没有这么做,因为无名对象使用过后在整个程序中就失去了作用,对于这种情况c++会把代码看成是:
Internet a("中国软件开发实验室",www.cndev-lab.com);
省略了创建无名对象这一过程,所以说不会调用拷贝构造函数。
最后让我们来看看引用无名对象的情况。
|
引用本身是对象的别名,和复制并没有关系,所以不会调用拷贝构造函数,但要注意的是,在c++看来:
Internet &a=Internet("中国软件开发实验室","www.cndev-lab.com");
是等价与:
Internet a("中国软件开发实验室","www.cndev-lab.com");
的,注意观察调用析构函数的位置(这种情况是在main()外调用,而无名对象本身是在main()内析构的)。
上文部分内容和代码可能存在问题,望大家指出错误探讨!
原文地址:http://www.pconline.com.cn/pcedu/empolder/gj/c/0503/570112.html
作者:冯明德
重点:包含动态分配成员的类 应提供拷贝构造函数,并重载"="赋值操作符。
以下讨论中将用到的例子:
|
这个类的主要特点是包含指向其他资源的指针。
pBuffer指向堆中分配的一段内存空间。
一、拷贝构造函数
|
语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。
其完成方式是内存拷贝,复制所有成员的值。
完成后,theObjtwo.pBuffer==theObjone.pBuffer。
即它们将指向同样的地方,指针虽然复制了,但所指向的空间并没有复制,而是由两个对象共用了。这样不符合要求,对象之间不独立了,并为空间的删除带来隐患。
所以需要采用必要的手段来避免此类情况。
回顾以下此语句的具体过程:首先建立对象theObjtwo,并调用其构造函数,然后成员被拷贝。
可以在构造函数中添加操作来解决指针成员的问题。
所以C++语法中除了提供缺省形式的构造函数外,还规范了另一种特殊的构造函数:拷贝构造函数,上面的语句中,如果类中定义了拷贝构造函数,这对象建立时,调用的将是拷贝构造函数,在拷贝构造函数中,可以根据传入的变量,复制指针所指向的资源。
拷贝构造函数的格式为:构造函数名(对象的引用)
提供了拷贝构造函数后的CExample类定义为:
|
这样,定义新对象,并用已有对象初始化新对象时,CExample(const CExample& RightSides)将被调用,而已有对象用别名RightSides传给构造函数,以用来作复制。
原则上,应该为所有包含动态分配成员的类都提供拷贝构造函数。
拷贝构造函数的另一种调用。
当对象直接作为参数传给函数时,函数将建立对象的临时拷贝,这个拷贝过程也将调同拷贝构造函数。
例如
|
还有一种情况,也是与临时对象有关的
|
当函数中的局部对象被被返回给函数调者时,也将建立此局部对象的一个临时拷贝,拷贝构造函数也将被调用
二、赋值符的重载
下面的代码与上例相似
|
也用到了"="号,但与"一、"中的例子并不同,"一、"的例子中,"="在对象声明语句中,表示初始化。更多时候,这种初始化也可用括号表示。
例如 CExample theObjone(theObjtwo);
而本例子中,"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree;,这其中涉及到对象theObjthree原有内容的丢弃,新内容的复制。
但"="的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。
由于对象内包含指针,将造成不良后果:指针的值被丢弃了,但指针指向的内容并未释放。指针的值被复制了,但指针所指内容并未复制。
因此,包含动态分配成员的类除提供拷贝构造函数外,还应该考虑重载"="赋值操作符号。
类定义变为:
|
|
三、拷贝构造函数使用赋值运算符重载的代码。
|