曲径通幽论坛

标题: 将对象直接传递给函数及存在的潜在问题 [打印本页]
作者: beyes    时间: 2011-8-14 23:50
标题: 将对象直接传递给函数及存在的潜在问题
和其它类型的数据一样，对象也可以传递到函数中，但这也是值传递，而非传递对象本身，传递的是对象的一个副本。在函数中修改对象的值不会影响作为实际参数传递给函数的对象。下面函数说明了这一点：

[C++] 纯文本查看 复制代码


#include <iostream>

using namespace std;





class OBJ {

    int i;

public:

    void set_i(int x) { i = x; }

    void out_i() { cout << i << "\n"; }

};





void f(OBJ x)

{

    x.out_i();

    x.set_i(100);   //修改的只是对象 o 的副本

    x.out_i();

}





int main()

{

    OBJ o;

    o.set_i(10);

    f(o);    //传递对象 o 到函数 f() 中

    o.out_i();





    return 0;

}

运行输出：
$ ./passobj
10
100
10

上面例子的类中不存在构造函数与析构函数。下面看看当构造函数与析构函数存在时，会发生什么事情：
[C++] 纯文本查看 复制代码


#include <iostream>

using namespace std;



class myclass {

    int val;

public:

    myclass(int i) { val = i; cout << "Constructing\n"; }

    ~myclass() { cout << "Destructing\n"; }

    int getval() { return val; }

};

void display (myclass ob)

{

    cout << ob.getval() << "\n";

}



int main()

{

    myclass a(10);



    display(a);



    return 0;

}

运行输出：
$ ./passproblem
Constructing
10
Destructing
Destructing
从输出可以看出，只调用了 1 次构造函数，却调用了 2 次析构函数。被调用的构造函数显然是在 main() 中创建 a 对象时所调用。那在传递 a 到函数 display() 中有没有调用构造函数呢？

在调用函数 display() 并传递 a 给它时，程序创建了一个 a 对象的副本，此时正常的构造函数并没有被调用，但是调用了一个 “复制构造函数”，默认情况下，这个“复制构造函数” 的调用是隐式的。

“复制构造函数” 定义了如何创建一个对象的副本 --- 当类中没有显示的定义 “复制构造函数” 的话，那么 C++ 就为其提供一个默认的 “复制构造函数” 。默认的 “复制构造函数” 将以按位复制的形式创建一个对象的副本。

有了 “复制构造函数” 这个概念，就容易理解为什么在传递对象参数时，没有去调用普通的构造函数了。这是因为：普通的构造函数通常是用来初始化对象的某些成员。所以，在一个对象被创建后，可能已经改动了这些被初始化过的成员。此时，如果我们在传递这个对象到另外的函数中时再调用一下构造函数，那么我们看到的又是被初始化的成员 --- 然而，实际上，我们在传递一个对象到函数中时，我们希望得到的是该对象的当前状态，而不是初始状态。

但是，当函数结束时，由于被传递进来的对象副本相当于一个局部变量，它的作用范围仅限于调用函数中，所以在函数结束时，该副本被销毁，从而调用了析构函数。这样就是上面的程序输出中为什么会出现 2 个析构函数中的输出 --- 一个输出是在 display() 函数结束时，另一个是在 main() 函数结束时。

总结：当创建一个对象的副本作为函数的参数时，普通的构造函数没有被调用，所调用的构造函数是按位复制的默认“复制构造函数”。但是，当副本被销毁时，析构函数会被调用。

然而，在使用默认的“复制构造函数”时会存在潜在问题。假设有这么一种情况：
当我们在用作实际参数的对象中分配了动态内存(比如上面的 a 对象中用 malloc() 分配了一段动态内存)，并且在销毁时释放内存，那么函数中实际参数的副本在调用析构函数时也将释放同样的内存。这时就会出现问题了，这样造成了原始的实际参数对象仍被用的那块内存被副本给释放了，这会破坏了原始对象而且使得对象变得不可用。下面程序演示这种情况：
[C++] 纯文本查看 复制代码


#include <iostream>

#include <cstdlib>

#include <cstring>

using namespace std;



class myclass {

    char *p;

public:

    myclass(const char *str);

    ~myclass();

    int show() { cout << p << "\n"; }

};



myclass::myclass(const char *str)

{

    cout << "Allocating p\n";

    p = (char *)malloc (100);

    strcpy(p, str);

}



myclass::~myclass()

{

    cout << "Freeing p\n";

    free (p);

}



void display(myclass ob)

{

    cout << ob.show() << "\n";

}



int main()

{

    myclass a("hello world");



    display(a);



    return 0;

}

运行输出：
[beyes@beyes   cpp]$ ./passpb
Allocating p
hello world
134520064
Freeing p
Freeing p
*** glibc detected *** ./passpb: double free or corruption (top): 0x09b9f008 ***
======= Backtrace: =========
/lib/libc.so.6(+0x712b5)[0xd3d2b5]
./passpb[0x804875f]
./passpb[0x80487e3]
/lib/libc.so.6(__libc_start_main+0xf3)[0xce5413]
./passpb[0x8048661]
======= Memory map: ========
00110000-00138000 r-xp 00000000 fd:01 1966809    /lib/libm-2.14.so
00138000-00139000 r--p 00028000 fd:01 1966809    /lib/libm-2.14.so
00139000-0013a000 rw-p 00029000 fd:01 1966809    /lib/libm-2.14.so
001d6000-001f3000 r-xp 00000000 fd:01 1966794    /lib/ld-2.14.so
001f3000-001f4000 r--p 0001d000 fd:01 1966794    /lib/ld-2.14.so
001f4000-001f5000 rw-p 0001e000 fd:01 1966794    /lib/ld-2.14.so
00276000-00277000 r-xp 00000000 00:00 0          [vdso]
0076e000-0084d000 r-xp 00000000 fd:01 660656     /usr/lib/libstdc++.so.6.0.16
0084d000-0084e000 ---p 000df000 fd:01 660656     /usr/lib/libstdc++.so.6.0.16
0084e000-00852000 r--p 000df000 fd:01 660656     /usr/lib/libstdc++.so.6.0.16
00852000-00853000 rw-p 000e3000 fd:01 660656     /usr/lib/libstdc++.so.6.0.16
00853000-0085a000 rw-p 00000000 00:00 0
00b6c000-00b88000 r-xp 00000000 fd:01 1967785    /lib/libgcc_s-4.6.0-20110603.so.1
00b88000-00b89000 rw-p 0001b000 fd:01 1967785    /lib/libgcc_s-4.6.0-20110603.so.1
00ccc000-00e51000 r-xp 00000000 fd:01 1966801    /lib/libc-2.14.so
00e51000-00e52000 ---p 00185000 fd:01 1966801    /lib/libc-2.14.so
00e52000-00e54000 r--p 00185000 fd:01 1966801    /lib/libc-2.14.so
00e54000-00e55000 rw-p 00187000 fd:01 1966801    /lib/libc-2.14.so
00e55000-00e58000 rw-p 00000000 00:00 0
08048000-08049000 r-xp 00000000 fd:02 1189533    /home/beyes/cpp/passpb
08049000-0804a000 rw-p 00000000 fd:02 1189533    /home/beyes/cpp/passpb
09b9f000-09bc0000 rw-p 00000000 00:00 0          [heap]
b77be000-b77c1000 rw-p 00000000 00:00 0
b77d7000-b77da000 rw-p 00000000 00:00 0
bf958000-bf979000 rw-p 00000000 00:00 0          [stack]
Aborted (core dumped)
由输出可以看到，程序发生了致命错误，崩溃了。下面分析一下原因：
在 main() 中的对象 a 被初始化时，程序为指针 a.p 分配了内存。当对象 a 作为参数产地给函数 display() 时，a 的值就被赋给了形式参数 ob。也就是说，在对象 a 和 ob 中，p 的值是一样的，指针 p 指向的是同一块动态分配的内存。当 display() 函数结束时，局部对象 ob 被销毁，它的析构函数被调用，然而析构函数所释放的 ob.p 所指向的内存仍然被 a.p 使用！当程序结束时，a.p 指向的内存再次被释放！对同一块动态内存释放两次在 C++ 中是未定义的操作，这个操作的定义依赖于实现动态内存分配系统的方式，因此这将产生严重的错误！

既然形式参数的析构函数销毁了实际的参数需要的数据，那么避开这个问题的方法之一就是传递一个对象指针或者对象引用，而不是对象的副本，这样在函数返回时将不会调用析构函数。一般情况下，通过引用来传递对象是最好的方法，但也并不能适用于所有情况。一种更为常用的解决方法就是自定义“复制构造函数”。这种方法可以精确地定义如何创建一个对象的副本，从而避免上述问题。



欢迎光临 曲径通幽论坛 (http://www.groad.net/bbs/) Powered by Discuz! X3.2