基于c++中的默认拷贝函数的使用详解

《c++编程思想》上说一个类如果没有拷贝函数,那么编译器就会自动创建一个默认的拷贝函数。下面就让我们看一下真实的情况。

首先看一个简单的类X,这个类没有显示定义拷贝构造函数。

c++源码如下:


代码如下:

class X {
private:
    int i;
    int j;
};

int main() {
    X x1;//先定义对象x1
    X x2 = x1;//将x1拷贝给x2
}

下面是其汇编代码:


代码如下:

_main    PROC

; 7    : int main() {

push    ebp
    mov    ebp, esp
    sub    esp, 16                    ; 为对象x1,x2预留16byte的栈空间

; 8    :     X x1;//先定义对象x1
; 9    :     X x2 = x1;//将x1拷贝给x2

mov    eax, DWORD PTR _x1$[ebp];将x1的首地址里面的内容给寄存器eax,也就将x1中的成员变量i的值给eax
    mov    DWORD PTR _x2$[ebp], eax;将eax里面的值写入x2的首地址,也就是将eax里面的值写给x2的成员变量i
    mov    ecx, DWORD PTR _x1$[ebp+4];将偏移x1首地址4byte的内存里面的值给寄存器eax,也就是将x1中的成员变量j的值给ecx
    mov    DWORD PTR _x2$[ebp+4], ecx;将ecx里面的值写入偏移x2首地址4byte的内存里面,也就是将ecx里面的值写给x2的成员变量j

; 10   : }

xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0
_main    ENDP

从汇编代码里面可以看出,根本没有函数被调用,所有的拷贝赋值都是通过寄存器与内存地址相互通信完成。和编译器提供默认构造函数一样,可以把这种情况看成是编译器提供了一个无用的拷贝构造函数。

那么,什么时候编译器才真正的提供默认拷贝构造函数,并且显示调用呢?

下面是一种情况,类X里面含有虚成员函数:

c++源码:


代码如下:

class X {
private:
    int i;
    int j;
public:
    virtual ~X() {}//虚析构函数
};

int main() {
    X x1;//先定义对象x1
    X x2 = x1;//将x1拷贝给x2
}

由于这里只讨论拷贝函数,所以只看主函数main和拷贝函数里面的汇编代码:

下面是主函数main里面的汇编代码:


代码如下:

_main    PROC

; 9    : int main() {

push    ebp
    mov    ebp, esp
    sub    esp, 24                    ; 由于引入了虚函数,每个类所占的空间编程12byte 成员变量i,j8byte vptr指针4byte 因此这里为x1 x2预留24byte

; 10   :     X x1;//先定义对象x1

lea    ecx, DWORD PTR _x1$[ebp];获取x1的首地址,放入ecx,为调用构造函数的秘密参数传入,即this
    call    ??0X@@QAE@XZ;调用构造函数

; 11   :     X x2 = x1;//将x1拷贝给x2

lea    eax, DWORD PTR _x1$[ebp];获取x1的首地址,放入寄存器eax
    push    eax;将eax压栈,作为拷贝构造函数的参数
    lea    ecx, DWORD PTR _x2$[ebp];获取x2的首地址,放入寄存器ecx,作为调用拷贝构造函数的秘密参数传入,即this
    call    ??0X@@QAE@ABV0@@Z;调用拷贝构造函数

; 12   : }

lea    ecx, DWORD PTR _x2$[ebp];获取x2的首地址,放入ecx寄存器,作为调用析构函数传入的秘密参数,即this
    call    ??1X@@UAE@XZ                ; 调用析构函数
    lea    ecx, DWORD PTR _x1$[ebp];获取x1的首地址,放入ecx寄存器,作为调用析构函数传入的秘密参数,即this
                                ;析构的顺序与构建的顺序相反
    call    ??1X@@UAE@XZ                ; 调用析构函数
    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0
_main    ENDP

可以看到,编译器为类X提供了默认的拷贝构造函数(非无用的默认拷贝构造函数),并且显示调用。

由于一个类继承自虚基类或者继承自有虚函数成员的基类,使得它本身也含有虚函数成员,因此也就属于上一种情形。所以编译器在这种情况下,也会提供非无用的默认拷贝构造函数,并且能够显示调用。

下面是第二种情形,类X继承自类Y,类Y有显示定义的拷贝构造函数,而类没有提供拷贝构造函数:

下面是c++源码:


代码如下:

class Y {
private:
    int j;
public:
   Y(const Y& y) {}
   Y() {};//必须为Y提供默认的构造函数,否则编译出错
};
class X : public Y {
private:
    int i;
    int j;
};

int main() {
    X x1;//先定义对象x1
    X x2 = x1;//将x1拷贝给x2
}

下面是mian函数汇编代码:


代码如下:

; 16   : int main() {

push    ebp
    mov    ebp, esp
    sub    esp, 24                    ; 为x1 x2预留24byte空间

; 17   :     X x1;//先定义对象x1

lea    ecx, DWORD PTR _x1$[ebp];获取x1的首地址,作为隐含参数传递给构造函数
    call    ??0X@@QAE@XZ;//调用编译器为类X提供的默认构造函数

; 18   :     X x2 = x1;//将x1拷贝给x2

lea    eax, DWORD PTR _x1$[ebp];获取x1的首地址,传给寄存器eax
    push    eax;将eax压栈,作为调用类X的拷贝构造函数的参数
    lea    ecx, DWORD PTR _x2$[ebp];获取x2的首地址,作为调用类X的拷贝函数的隐含参数
    call    ??0X@@QAE@ABV0@@Z;调用编译器提供的默认拷贝构造函数

; 19   : }

xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0

下面是类X的拷贝构造函数的汇编码:


代码如下:

??0X@@QAE@ABV0@@Z PROC                    ; X::X, COMDAT
; _this$ = ecx
    push    ebp
    mov    ebp, esp
    push    ecx
    mov    DWORD PTR _this$[ebp], ecx;ecx里面有x2的首地址
    mov    eax, DWORD PTR ___that$[ebp];将x1的首地址给eax
    push    eax;将eax的首地址压栈,作为调用父类拷贝构造函数的参数
    mov    ecx, DWORD PTR _this$[ebp];将x2的首地址给ecx,作为隐含参数传给父类的拷贝构造函数
    call    ??0Y@@QAE@ABV0@@Z            ; 调用父类拷贝构造函数
    mov    ecx, DWORD PTR _this$[ebp];获取x2的首地址给ecx
    mov    edx, DWORD PTR ___that$[ebp];获取x1的首地址给edx
    mov    eax, DWORD PTR [edx+4];将偏移x1首地址4byte处的内存里面的值写给eax,即将x1中子类成员变量i的值写给eax,因为x1的首地址处存放的是父类成员变量i,其值
                              ;由父类拷贝构造函数负责拷贝给x2
    mov    DWORD PTR [ecx+4], eax;将eax的值写入偏离x2首地址4byte处的内存里面,即将eax的值写入x2中子类成员变量i,因为x2的首地址处存放父类成员变量i,其值
                              ;由父类拷贝构造函数负责拷贝
    mov    ecx, DWORD PTR _this$[ebp];将x2的首地址给ecx
    mov    edx, DWORD PTR ___that$[ebp];将x1的首地址给edx
    mov    eax, DWORD PTR [edx+8];将偏移x1首地址8byte处的内存里面的值给eax,即将x1中子类成员变量j的值给eax
    mov    DWORD PTR [ecx+8], eax;将eax的值写入偏移x2首地址8byte的内存里面,即将eax的值写入x2子类成员j中
    mov    eax, DWORD PTR _this$[ebp];将x2的首地址给eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    4
??0X@@QAE@ABV0@@Z ENDP

从汇编码中可以看到,编译器确实为类X提供了默认的拷贝构造函数,并且进行了显示调用。而且在调用类X的拷贝构造函数中,首先调用父类的拷贝构造函数,拷贝父类中的成员变量,然后再拷贝子类中的成员变量。

下面是父类Y中的拷贝构造函数汇编码:


代码如下:

??0Y@@QAE@ABV0@@Z PROC                    ; Y::Y, COMDAT
; _this$ = ecx

; 5    :    Y(const Y& y) {}

push    ebp
    mov    ebp, esp
    push    ecx;//这里压栈的目的是为隐含传给父类拷贝函数的this(即x2的首地址)
    mov    DWORD PTR _this$[ebp], ecx;ecx里面含有x2的首地址(即this),放入刚才的预留空间
    mov    eax, DWORD PTR _this$[ebp];将x2的首地址写入eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    4
??0Y@@QAE@ABV0@@Z ENDP                    ; Y::Y
_TEXT    ENDS

从汇编吗可以看到,由于父类自己显示定义了拷贝构造函数,编译器只是负责调用而已,并不提供像上面子类X里面默认拷贝构造函数的拷贝功能,即并不拷贝父类成员变量i。因为,在c++源码里面,父类拷贝构造函数本身就是空函数,什么也不做。

如果子类X 父类Y都不提供拷贝构造函数,情形有时怎样的呢?

下面是c++源码:


代码如下:

class Y {
private:
    int j;
};
class X : public Y {
private:
    int i;
    int j;
};

int main() {
    X x1;//先定义对象x1
    X x2 = x1;//将x1拷贝给x2
}

下面是对应的汇编码:


代码如下:

_main    PROC

; 12   : int main() {

push    ebp
    mov    ebp, esp
    sub    esp, 24                    ; 为x1 x2预留24byte空间

; 13   :     X x1;//先定义对象x1
; 14   :     X x2 = x1;//将x1拷贝给x2

mov    eax, DWORD PTR _x1$[ebp];获取x1的首地址里面的值,存入eax,即获取x1父类成员变量i的值写给eax
    mov    DWORD PTR _x2$[ebp], eax;将eax的值写入x2的首地址指向的内存,即将eax的值写给x2中的父类成员变量i
    mov    ecx, DWORD PTR _x1$[ebp+4];获取偏移x1首地址4byte处的内存里面的值,写入ecx,即获取x1子类成员变量i的值写给ecx
    mov    DWORD PTR _x2$[ebp+4], ecx;将ecx的值写入偏移x2首地址4byte处的内存里面,即将ecx的值写给x2中子类成员变量i
    mov    edx, DWORD PTR _x1$[ebp+8];获取偏移x1首地址8byte处的内存里面的值,写入edx,即获取x1子类成员变量j的值写给edx
    mov    DWORD PTR _x2$[ebp+8], edx;将edx的值写入偏移x2首地址8byte处的内存里面,即将edx的值写入x2子类成员变量j

; 15   : }

xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0
_main    ENDP

可以看到,编译器执行了拷贝过程,但是提供的是像刚开始的无用的默认拷贝构造函数,无论是拷贝父类成员变量,还是子类成员变量,都没有函数的调用。

下面看第三种情况,类X含有类Y的成员变量,类Y的成员变量有拷贝构造函数。

c++源码如下:


代码如下:

class Y {
private:
    int j;
public:
    Y(const Y& y) {}
    Y() {}//必须为Y提供默认的构造函数,否则编译报错
};
class X  {
private:
    int i;
    int j;
    Y y;
};

int main() {
    X x1;//先定义对象x1
    X x2 = x1;//将x1拷贝给x2
}

下面是main函数中的汇编码:


代码如下:

_main    PROC

; 16   : int main() {

push    ebp
    mov    ebp, esp
    sub    esp, 24                    ; 为x1 x2预留24byte的空间

; 17   :     X x1;//先定义对象x1

lea    ecx, DWORD PTR _x1$[ebp];获取x1的首地址,作为隐含参数传递给构造函数
    call    ??0X@@QAE@XZ;调用构造函数

; 18   :     X x2 = x1;//将x1拷贝给x2

lea    eax, DWORD PTR _x1$[ebp];获取x1的首地址,放入寄存器eax
    push    eax;将eax压栈,为作为参数传递给编译器提供的默认拷贝构造函数
    lea    ecx, DWORD PTR _x2$[ebp];获取x2的首地址,作为隐含参数传递给编译器提供的默认拷贝构造函数
    call    ??0X@@QAE@ABV0@@Z;调用拷贝构造函数

; 19   : }

xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0
_main    ENDP

下面是编译器为类X提供的默认拷贝构造函数的汇编码:


代码如下:

??0X@@QAE@ABV0@@Z PROC                    ; X::X, COMDAT
; _this$ = ecx
    push    ebp
    mov    ebp, esp
    push    ecx;压栈的目的是为this(即x2的首地址)预留空间
    mov    DWORD PTR _this$[ebp], ecx;ecx里面含有x2的首地址,放入刚才预留的空间里面
    mov    eax, DWORD PTR _this$[ebp];将x2的首地址给eax
    mov    ecx, DWORD PTR ___that$[ebp];将x1的首地址给ecx
    mov    edx, DWORD PTR [ecx];将x1的首地址的内容写入edx,即将x1中的成员变量i写入edx
    mov    DWORD PTR [eax], edx;将edx的值写入x2的首地址,即将edx的值写入x2的成员变量i
    mov    eax, DWORD PTR _this$[ebp];将x2的首地址写入寄存器eax
    mov    ecx, DWORD PTR ___that$[ebp];将x1的首地址写入寄存器ecx
    mov    edx, DWORD PTR [ecx+4];将偏移x1首地址4byte处的内存里面的值写入edx,即将x1的成员变量j的值写入edx
    mov    DWORD PTR [eax+4], edx;将edx的值写入偏移x2首地址4byte处的内存,即将edx的值写入x2的成员变量j
    mov    eax, DWORD PTR ___that$[ebp];将x1的首地址存入寄存器eax
    add    eax, 8;//将x1的首地址加8,得到x1中成员对象y所处的地址,放入eax中
    push    eax;将eax的值压栈,作为调用成员变量y的拷贝函数的参数
    mov    ecx, DWORD PTR _this$[ebp];将x2的首地址存入寄存器ecx
    add    ecx, 8;将x2的首地址加8,得到x2中成员对象y所在地址,放入ecx,这个地址作为隐含的参数传给成员变量函数的拷贝构造函数
    call    ??0Y@@QAE@ABV0@@Z            ; 调用成员对象y的拷贝构造函数
    mov    eax, DWORD PTR _this$[ebp];将x2的首地址放入eax,作为返回值。构造函数总是返回对象的首地址
    mov    esp, ebp
    pop    ebp
    ret    4
??0X@@QAE@ABV0@@Z ENDP

从汇编吗可以看到,调用类X拷贝构造函数的时候,先将x1中的成员变量i,j拷贝到x2中,然后才是调用成员对象y的拷贝构造函数拷贝y中的成员变量。这和继承不同,在继承中,总是先调用父类的拷贝构造函数,再进行子类中的拷贝。这说明,对于这种包含成员对象的情况,成员对象的拷贝函数调用时机与他们定义的位置有关。在这里,类X的成员对象y在成员变量i,j之后定义,因此,它的拷贝构造函数要等拷贝完i,j之后才会被调用。

下面是类Y中的拷贝构造函数汇编代码:


代码如下:

??0Y@@QAE@ABV0@@Z PROC                    ; Y::Y, COMDAT
; _this$ = ecx

; 6    :     Y(const Y& y) {}

push    ebp
    mov    ebp, esp
    push    ecx;压栈ecx的目的是为了存放this(x2中成员对象y的首地址)预留空间
    mov    DWORD PTR _this$[ebp], ecx;ecx里面有x2中成员对象y的首地址,放入刚才的预留空间
    mov    eax, DWORD PTR _this$[ebp];将x2中成员变量首地址放入eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    4
??0Y@@QAE@ABV0@@Z ENDP

从代码中可以看到,由于类Y显示定义了拷贝构造函数,编译器也只是负责显示调用,并没有提供任何的拷贝功能。因为在类Y中,拷贝构造函数就是被定义成了一个空函数

和继承一样,如果成员对象也没有拷贝构造函数呢?

下面是c++源码:


代码如下:

class Y {
private:
    int j;

};
class X  {
private:
    int i;
    int j;
    Y y;
};

int main() {
    X x1;//先定义对象x1
    X x2 = x1;//将x1拷贝给x2
}

下面是对象的汇编码:


代码如下:

_main    PROC

; 14   : int main() {

push    ebp
    mov    ebp, esp
    sub    esp, 24                    ; 00000018H

; 15   :     X x1;//先定义对象x1
; 16   :     X x2 = x1;//将x1拷贝给x2

mov    eax, DWORD PTR _x1$[ebp];将x1中首地址的内容写入eax,即将x1中的成员变量值i写入eax
    mov    DWORD PTR _x2$[ebp], eax;将eax的值写入x2的首地址处,即将eax的值写入x2的成员变量i
    mov    ecx, DWORD PTR _x1$[ebp+4];将偏移x1首地址4byte处的内存里面的内容写入ecx,即将x1中成员变量j的值写入ecx
    mov    DWORD PTR _x2$[ebp+4], ecx;将ecx的值写入偏移x2首地址4byte处的内存,即将ecx的值写入x2中成员变量j
    mov    edx, DWORD PTR _x1$[ebp+8];将偏移x1首地址8byte处(这里是x1成员对象y的首地址)的内存值写入edx,即将x1中成员对象y中的成员变量i值写入edx
    mov    DWORD PTR _x2$[ebp+8], edx;将edx的值写入偏移x2首地址8byte处(这里是x2成员对象y的首地址)的内存里面,即将edx的值写入x2中成员对象y的成员变量i里面

从汇编吗可以看出,编译器在这种情况下任然只是提供无用的默认拷贝构造函数,即没有显示的函数调用,只是用寄存器和内存之间的通信完成拷贝过程

综合上面的分析,可以看到:

对于一个类,如果它没有显示定义拷贝构造函数,编译器并不总是提供非无用的默认拷贝构造函数,除非:

1 该类包含虚函数成员函数(包括继承自虚基类或者继承的基类中有虚函数成员),这时编译器提供为该类提供非无用的默认拷贝构造函数

2 该类继承自一个基类,而基类含有自定义的拷贝函数,这时编译器为该类提供非无用的默认拷贝构造函数。(如果基类本身没有定义拷贝构造函数,但是编译器会为基类提供一个非无用的默认拷贝构造函数,也属于这种情况。也就是说,基类只要含有一个非无用的拷贝构造函数就行,不管这个非无用的拷贝构造函数是自定义的,还是编译器提供的)

3 该类包含一个成员对象,而该成员对象有自定的拷贝构造函数,这时编译器为该类提供非无用的默认拷贝构造函数。(如果成员对象本身没有定义拷贝构造函数,但是编译器会为成员对象提供一个非无用的默认拷贝构造函数,也属于这种情况。也就是说,成员对象只要包含一个非无用的拷贝构造函数就行,不管这个非无用的拷贝构造函数时自定义的,还是编译器提供的。这中情况和上一种类似).

并且,如果一个类自定义了一个拷贝构造函数,编译器只是负责调用,不会额外提供任何拷贝过程;而对于编译器提供的默认拷贝函数,不管是无用的,还是非无用的,都仅仅只是位拷贝(即浅拷贝).

时间: 2013-05-11

C++中拷贝构造函数的应用详解

一.C++中拷贝构造函数的定义: 有一个参数的类型是其类类型的构造函数是为拷贝构造函数. 如下所示: X::X( const X& x); Y::Y( const Y& y, int =0 ); //可以是多参数形式,但其第二个即后继参数都有一个默认值 二.拷贝构造函数的应用: 当一个类对象以另一个同类实体作为初值时,大部分情况下会调用拷贝构造函数. 一般是这三种具体情况: 1.显式地以一个类对象作为另一个类对象的初值,形如X xx=x; 2.当类对象被作为参数交给函数时. 3.当函数返回

深入理解C/C++中的写时拷贝

写时拷贝 何为写时拷贝? 前面我说过深拷贝浅拷贝,今天我们来探究一下写时拷贝.深拷贝是补充了浅拷贝的不足,写时拷贝其实也就是补充一点深拷贝的不足.其实写时拷贝的意思就是: 当你读取到这个空间的时候,并不会开辟出一个一模一样的空间出来给你,当你真正需要拷贝的时候,那么他就会开辟出空间给你.也就是拖延版的深拷贝. 写时拷贝技术是通过"引用计数"实现的,在分配空间的时候多分配4个字节,用来记录有多少个指针指向块空间,当有新的指针指向这块空间时,引用计数加一,当要释放这块空间时,引用计数减一(

C++拷贝构造函数(深拷贝与浅拷贝)详解

对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. 复制代码 代码如下: #include <iostream>using namespace std; class CExample {private:    int a;public:    CExample(int b)    { a=b;}    void Show ()    {       

c++拷贝构造函数防篡改示例

对于普通类型的对象来说,他们之间的复制是简单的,比如: 复制代码 代码如下: int a = 88;int b = a; 而类和普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量. 复制代码 代码如下: #include <iostream>using namespace std; class CExample {private: int a;public:     CExample(int b) { a=b;} void Show () {        cout<<a&

C++友元函数与拷贝构造函数详解

一.友元函数 1.友元函数概述: (1)友元函数是定义在一个类外的普通函数. 友元函数和普通函数的定义一样;在类内必须将该普通函数声明为友元. (2)友元函数不是成员函数. 不能通过对象来调用,而是直接调用;友元函数可以访问类的公有.受保护以及私有成员,但是必须通过对象.对象指针或者对象引用来访问. 2.友元函数的声明: friend 返回值类型 函数名(参数表); 在类中只需要将这个声明放置在公有部分即可. class Point { double x, y; public: Point(){

c++面试题字符串拷贝函数示例

复制代码 代码如下: #include<iostream>using namespace std; //字符串拷贝函数char * sCpy(char *strDest, char *strSource){    _ASSERT((strDest != NULL) && (strSource!=NULL));    char *d = strDest;              //获取dest的当前位置    char *s = strSource;            /

深入C++拷贝构造函数的总结详解

拷贝构造函数是C++最基础的概念之一,大家自认为对拷贝构造函数了解么?请大家先回答一下三个问题:1. 以下函数哪个是拷贝构造函数,为什么?X::X(const X&);   X::X(X);   X::X(X&, int a=1);   X::X(X&, int a=1, b=2);  2. 一个类中可以存在多于一个的拷贝构造函数吗?3. 写出以下程序段的输出结果, 并说明为什么? 如果你都能回答无误的话,那么你已经对拷贝构造函数有了相当的了解. #include <iost

c++中拷贝构造函数的参数类型必须是引用

在C++中, 构造函数,拷贝构造函数,析构函数和赋值函数(赋值运算符重载)是最基本不过的需要掌握的知识. 但是如果我问你"拷贝构造函数的参数为什么必须使用引用类型?"这个问题, 你会怎么回答? 或许你会回答为了减少一次内存拷贝? 很惭愧的是,我的第一感觉也是这么回答.不过还好,我思索一下以后,发现这个答案是不对的. 原因:如果拷贝构造函数中的参数不是一个引用,即形如CClass(const CClass c_class),那么就相当于采用了传值的方式(pass-by-value),而传

深入C++中构造函数、拷贝构造函数、赋值操作符、析构函数的调用过程总结

1 . 用同一个类的源对象构造一个目标对象时,会调用拷贝构造函数来构造目标对象,如果没有定义拷贝构造函数,将调用类的默认拷贝函数来构造目标对象.2 . 当一个函数的返回值为一个类的对象时,如果在调用函数中,没有定义一个对象来接收这个返回对象值,会用返回一个临时对象保存返回对象的值.在被调用函数结束时,这个临时对象被销毁.而当调用函数中有一个接受对象时,就将返回对象赋值给接收对象,这个返回对象在调用函数结束时调用析构函数.3. 当类有一个带有一个参数的构造函数时,可以用这个参数同类型的数据初始化这

C++中拷贝构造函数的总结详解

1.什么是拷贝构造函数: 拷贝构造函数嘛,当然就是拷贝和构造了.(其实很多名字,只要静下心来想一想,就真的是顾名思义呀)拷贝又称复制,因此拷贝构造函数又称复制构造函数.百度百科上是这样说的:拷贝构造函数,是一种特殊的构造函数,它由编译器调用来完成一些基于同一类的其他对象的构建及初始化.其唯一的参数(对象的引用)是不可变的(const类型).此函数经常用在函数调用时用户定义类型的值传递及返回. 2.拷贝构造函数的形式 复制代码 代码如下: Class X{public: X(); X(const

Linux中拷贝 cp命令中拷贝所有的写法详解

今天在编写一个脚本的时候,发现一个比较奇怪的问题:就是在使用cp拷贝当前目录下所有文件到目标目录的时候,源和目标目录大小不同.原来一直没有留意有这样的问题,后来查了些资料,才知道以前一直使用的格式有误, 一.预备 cp就是拷贝,最简单的使用方式就是: cp oldfile newfile 但这样只能拷贝文件,不能拷贝目录,所以通常用: cp -r old/ new/ 那就会把old目录整个拷贝到new目录下.注意,不是把old目录里面的文件拷贝到new目录,而是把old直接拷贝到new下面,结果

C++ 中构造函数的实例详解

C++ 中构造函数的实例详解 c++构造函数的知识在各种c++教材上已有介绍,不过初学者往往不太注意观察和总结其中各种构造函数的特点和用法,故在此我根据自己的c++编程经验总结了一下c++中各种构造函数的特点,并附上例子,希望对初学者有所帮助. 1. 构造函数是干什么的 class Counter { public: // 类Counter的构造函数 // 特点:以类名作为函数名,无返回类型 Counter() { m_value = 0; } private: // 数据成员 int m_va

Java 中This用法的实例详解

 Java 中This用法的实例详解 用类名定义一个变量的时候,定义的只是一个引用,外面可以通过这个引用来访问这个类里面的属性和方法. 那们类里面是够也应该有一个引用来访问自己的属性和方法纳? 呵呵,Java提供了一个很好的东西,就是 this 对象,它可以在类里面来引用这个类的属性和方法.先来个简单的例子: public class ThisDemo { String name="Mick"; public void print(String name){ System.out.pr

jsp 中HttpClient中的POST方法实例详解

jsp 中HttpClient中的POST方法实例详解 POST方法用来向目的服务器发出请求,要求它接受被附在请求后的实体,并把它当作请求队列(Request-Line)中请求URI所指定资源的附加新子项.POST被设计成用统一的方法实现下列功能: 对现有资源的注释 向电子公告栏.新闻组,邮件列表或类似讨论组发送消息 提交数据块,如将表单的结果提交给数据处理过程 通过附加操作来扩展数据库 调用HttpClient中的PostMethod与GetMethod类似,除了设置PostMethod的实例

Java中IO流 字节流实例详解

Java中IO流 字节流实例详解 IO流(输入流.输出流),又分为字节流.字符流. 流是磁盘或其它外围设备中存储的数据的源点或终点. 输入流:程序从输入流读取数据源.数据源包括外界(键盘.文件.网络-),即是将数据源读入到程序的通信通道. 输出流:程序向输出流写入数据.将程序中的数据输出到外界(显示器.打印机.文件.网络-)的通信通道. 字节流 1.InputStream.OutputStream InputStream抽象了应用程序读取数据的方式 OutputStream抽象了应用程序写出数据

Android 中 Tweened animation的实例详解

Android 中 Tweened animation的实例详解 Tweened animation有四种类型,下面主要介绍Scale类型. 运行效果如下: Android SDK提供了2种方法:直接从XML资源中读取Animation,使用Animation子类的构造函数来初始化Animation对象,第二种方法在看了Android SDK中各个类的说明就知道如何使用了,下面简要说明从XML资源中读取Animation.XML资源中的动画文件animation.xml内容为: <?xml ve

Java 重载、重写、构造函数的实例详解

Java 重载.重写.构造函数的实例详解 方法重写 1.重写只能出现在继承关系之中.当一个类继承它的父类方法时,都有机会重写该父类的方法.一个特例是父类的方法被标识为final.重写的主要优点是能够定义某个子类型特有的行为. class Animal { public void eat(){ System.out.println ("Animal is eating."); } } class Horse extends Animal{ public void eat(){ Syste