c++拷贝构造函数(深拷贝、浅拷贝)——转

拷贝构造函数:

拷贝构造函数是一种特殊的构造函数,函数的名称必须和类名称一致,它的唯一的一个参数是本类的一个引用变量,该参数是const类型,不可变的。例如:类A的拷贝构造函数的形式为A(A& x)。当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝函数就会被自动调用。也就是说,当类的对象需要拷贝时,拷贝构造函数将会被调用。以下情况会自动调用拷贝构造函数:

  1、一个对象以值传递的方式传入函数体

  2、一个对象以值传递的方式从函数返回,如下:

#include <iostream>
using namespace std;
class B
{
public:
    B(){cout<<"构造函数B"<<endl;}
    B(int i):data(i){cout<<"构造函数B"<<" "<<data<<endl;}
    B play(B b){return b;}
    ~B(){cout<<"析构函数B"<<endl;}
private:
    int data;
};
int main()
{
    B temp;
    temp.play(5);
    return 0;
}

  3、一个对象需要通过另一个对象进行初始化

如果在类中没有显示地声明一个拷贝构造函数,那么编译器会自动生成一个默认的拷贝构造函数,该构造函数完成对象之间的拷贝。自定义拷贝构造函数是一种良好的编程风格,它可以阻止编译器形成默认的拷贝构造函数,提高源码效率。

深拷贝和浅拷贝:

在某些情况下,类内成员变量需要动态开辟堆内存,如果实行位拷贝(位拷贝又称浅拷贝),也就是把对象里面的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员也指向同一块内存。这就出现了问题:把B内存释放了,这时A内的指针就是野指针了,出现运行错误。

深拷贝和浅拷贝可以简单理解为:如果一个类拥有资源,当这个类的对象发生复制过程的时候,资源重新分配,这个过程就是深拷贝,反之没有重新分配资源就是浅拷贝。

浅拷贝:

#include <iostream>
#include <string.h>
using namespace std;
class Example
{
private:
    int a;
    char *str;
public:
    Example()
    {
        cout<<"调用构造函数"<<endl;
    }
    ~Example()
    {
        cout<<"调用析构函数"<<endl;
    }

    Example(int b)
    {
        a=b;        cout<<"调用构造函数"<<endl;
    }
    Example(const Example& example)//自定义拷贝构造函数
    {
        a=example.a;
    }
    void show()
    {
        cout<<a<<endl;
    }
};

int main()
{
    Example a1(10);
    Example a2=a1;
    a2.show();
    return 0;
}

输出:

  调用构造函数

  10

  调用析构函数

  调用析构函数

深拷贝:

#include <iostream>
#include <string.h>
using namespace std;
class Example
{
private:
    int a;
    char *str;
public:
    Example()
    {
        cout<<"调用构造函数"<<endl;
    }
    ~Example()
    {
        delete str;
        cout<<"调用析构函数"<<endl;
    }

    Example(int b,char* e_str)
    {
        a=b;
        str=new char[b];
        strcpy(str,e_str);     cout<<"调用构造函数"<<endl;
    }
    Example(const Example& example)//自定义拷贝构造函数
    {
        a=example.a;
        str=new char[a];//深拷贝
        if(str!=0)
            strcpy(str,example.str);
    }
    void show()
    {
        cout<<str<<endl;
    }
};

int main()
{
    Example a1(10,"Hello");
    Example a2=a1;
    a2.show();
    return 0;
}

输出:

  调用构造函数

  Hello

  调用析构函数

  调用析构函数

参考地址:https://www.cnblogs.com/BlueTzar/articles/1223313.html

原文地址:https://www.cnblogs.com/ybf-yyj/p/9319765.html

时间: 2024-10-29 09:52:20

c++拷贝构造函数(深拷贝、浅拷贝)——转的相关文章

C++拷贝构造函数(深拷贝&amp;浅拷贝)

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

【转载】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<

【转】 c++拷贝构造函数(深拷贝,浅拷贝)详解

c++拷贝构造函数(深拷贝,浅拷贝)详解 2013-11-05 20:30:29 分类: C/C++ 原文地址:http://blog.chinaunix.net/uid-28977986-id-3977861.html 一.什么是拷贝构造函数      首先对于普通类型的对象来说,它们之间的复制是很简单的,例如: int a=100; int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.  下面看一个类对象拷贝的简单例子. #include<iostream

C++拷贝构造函数(深拷贝,浅拷贝)

http://www.cnblogs.com/BlueTzar/articles/1223313.html 对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. 1 #include <iostream> 2 using namespace std; 3 4 class CExample { 5 private: 6 int a; 7 public: 8

C++拷贝构造函数(浅拷贝、深拷贝)

下面举一个简单的例子说明对象之间的拷贝(此例中没有自定义拷贝构造函数,在调用拷贝构造函数的时候,编译器会自动生成一个默认的拷贝构造函数,该构造函数完成对象之间的位拷贝)浅拷贝: #include<iostream> using namespace std; class CExample { private:int a; public: CExample(int b) { a=b; } void Show() { cout<<a<<endl; } }; int main(

c++拷贝构造函数(深拷贝,浅拷贝)详解

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

拷贝构造函数(深拷贝vs浅拷贝)

类对象之间的初始化是由类的拷贝构造函数完成的.它是一种特殊的构造函数,它的作用是用一个已知的对象来初始化另一个对象.如果在类中没有显式地声明一个拷贝构造函数,那么,编译器将会自动生成一个默认的拷贝构造函数,该构造函数完成对象之间的位拷贝.位拷贝又称浅拷贝. 一.拷贝构造函数定义格式 类名::拷贝构造函数名(类名& 引用名) 例如: Tdate ::Tdate(Tdate & d); //形参是一个对象的引用 CString( const CString & stringSrc );

赋值运算符重载和拷贝构造函数 AND 浅拷贝与深拷贝

赋值运算符重载: 是用一个已经存在的对象去给另一个已经存在并初始化(调用过构造函数)的对象进行赋值. 拷贝构造函数:其实本质还是构造函数,用一个已存在的对象去构造一个原先不存在的对象. string a("hello"); string b("world"); string c =a ;   //拷贝构造函数 c = b;           //调用赋值函数 一般来说是在数据成员包含指针对象的时候,应付两种不同的处理需求的 一种是复制指针对象,一种是引用指针对象

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 ()      {