精华内容
下载资源
问答
  • 深拷贝构造函数和浅拷贝构造函数 拷贝构造函数有深拷贝构造函数和浅拷贝构造函数 分类:拷贝构造函数分为深拷贝构造函数和浅拷贝构造函数。 区别:浅拷贝,即只复制对象空间,不复制对象资源。 深拷贝,既复制...

    深拷贝构造函数和浅拷贝构造函数

    • 拷贝构造函数有深拷贝构造函数和浅拷贝构造函数

    分类:拷贝构造函数分为深拷贝构造函数和浅拷贝构造函数。
    区别:浅拷贝,即只复制对象空间,不复制对象资源。
    深拷贝,既复制对象空间又复制资源。
    由C++语言提供的默认拷贝构造函数只是对对象进行浅拷贝逐个成员依次拷贝。

    浅拷贝
    ~~在这里插入图片描述~~

    深拷贝和浅拷贝只在z指针变量中才有的说法,指针对象要用深拷贝,可是其他变量就不用。

    深拷贝

    在这里插入图片描述

    当数据成员中有指针时,如果采用简单的浅拷贝,则两类中的两个指针将指向同一个地址,当对象快结束时,会调用两次析构函数,而导致指针悬挂现象。所以,这时,必须采用深拷贝。

    #include <iostream>
    using namespace std;
    
    class sb {
    	public:
    		sb(char *na) //构造函数
    		{
    			cout << "FG ?" << endl;
    			name = new char[strlen(na) + 1];//new进行分配
    			if (name != 0) 
    			{
    				strcpy(name, na);
    			}
    		}
    		sb(sb &p) //深拷贝构造函数
    		{
    			cout << "FG win !" << endl;
    			name = new char[strlen(p.name) + 1];//复制资源
    			if (name != 0)
    				strcpy(name, p.name);//复制对象空间
    		}
    		void print() 
    		{
    			cout << name << endl;
    		}
    		~sb() 
    		{
    			delete name;
    		}
    	private:
    		char *name;
    };
    
    int main () {
    	sb niubi("wang");
    	sb li(niubi);
    	niubi.print();
    	li.print();
    	return 0;
    }
    
    展开全文
  • 拷贝构造函数:默认拷贝(浅拷贝)、深拷贝构造函数 分类: C/C++理论2009-02-24 13:23 1582人阅读 评论(4) 收藏 举报  一、 拷贝构造函数与构造函数的区别:  拷贝构造函数,是一种特殊的构造函数...

    拷贝构造函数:默认拷贝(浅拷贝)、深拷贝构造函数

    分类: C/C++理论 1582人阅读 评论(4) 收藏 举报

     一、 拷贝构造函数与构造函数的区别:

          拷贝构造函数,是一种特殊的构造函数,它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的参数(对象的引用)是不可变的(const类型)--参考分析1。

        拷贝构造函数与构造函数的区别:

      class 类名

      {

      public:

      类名(形参参数)//构造函数

      类名(类名&对象名)//拷贝构造函数

      ,,,,,,,,,,,,,,,,,,,,,

      };

      拷贝构造函数的实现:

      类名::类名(类名&对象名)//拷贝构造函数的实现

      {函数体}

      拷贝构造函数:

      Class Point

      {

      Public:

      Point(int xx=0,int yy=m)(X=xx;Y=yy;)

      Point(Point& p);

      Int getX() {return X;}

      Int getY(){ return Y;}

      Private :

      Int X,Y;

      }

      Point::Point(Point& p)

      {

      X=p.X;

      Y=p.Y;

      Cout<<"拷贝构造函数调用"<<endl;

      }

    二、拷贝构造函数介绍:

         在C++中,下面三种对象需要调用拷贝构造函数:

      1) 对象以值传递的方式传入函数体;

      2) 对象以值传递的方式从函数返回;

      3) 对象需要通过另外一个对象进行初始化;

          当使用已初始化对象去初始化另一个新对象的时候,拷贝构造函数就会被自动调用,如果没有自定义拷贝构造函数的时候系统将会提供默认的拷贝构造函数来完成这个过程;

          如果类体内的成员是需要开辟动态开辟堆内存的,而不自定义深拷贝构造函数,就会导致堆内存的所属权产生混乱,两个对象的指针指向同一个堆地址,一旦程序产生析构,释放堆的时候,计算机是不可能清楚这段地址是真正属于谁的,当连续发生两次析构的时候就出现了运行错误。

    #include <iostream>
    usingnamespacestd; 
    
    classInternet 
    { 
    public: 
    Internet(char*name,char*address) 
    { 
    cout<<"载入构造函数"<<endl;
    strcpy(Internet::name,name);
    strcpy(Internet::address,address); 
    cname=new char[strlen(name)+1]; 
    if(cname!=NULL) 
    { 
    strcpy(Internet::cname,name); 
    } 
    } 
    Internet(Internet &temp) 
    { 
        cout<<"载入COPY构造函数"<<endl;
        strcpy(Internet::name,temp.name);
        strcpy(Internet::address,temp.address); 
        cname=new char[strlen(name)+1];//这里注意,深拷贝的体现! 
        if(cname!=NULL) 
       { 
            strcpy(Internet::cname,name); 
        } 
    } 
    ~Internet() 
    { 
    cout<<"载入析构函数!"<<endl; 
    delete[] cname; 
    cin.get(); 
    } 
    voidshow(); 
    protected: 
    charname[20]; 
    charaddress[30]; 
    char*cname; 
    }; 
    void Internet::show() 
    { 
    cout<<"show 函数"<<endl;
    }
    voidtest(Internet ts) 
    { 
    cout<<"载入test函数"<<endl;
    }
    voidmain() 
    { 
    Internet a("中国软件开发实验室","www.cndev-lab.com"); 
    Internet b =a; 
    b.show(); 
    test(b); 
    }

    上面代码就演示了深拷贝的问题,对对象b的cname属性采取了新开辟内存的方式避免了内存归属不清所导致析构释放空间时候的错误,最后我必须提一下,对于上面的程序我的解释并不多,就是希望读者本身运行程序观察变化,进而深刻理解。

    深拷贝和浅拷贝的定义可以简单理解成:

    如果一个类拥有资源(堆,或者是其它系统资源),当这个类的对象发生复制过程(新开辟内存的方式)的时候,这个过程就可以叫做深拷贝;

    反之对象存在资源但复制过程并未复制资源(仅仅复制对象成员的指针,未新开辟内存)的情况视为浅拷贝。

     

    三、拷贝构造函数与赋值运算符:

    事实上,拷贝构造函数是由普通构造函数和赋值操作符共同实现的。

    赋值符的重载 :

    下面的代码与上例相似

      int main(int argc, char* argv[])

      {

      CExample theObjone;

      theObjone.Init(40);

      CExample theObjthree;

      theObjthree.Init(60);

      //现在需要一个对象赋值操作,被赋值对象的原内容被清除,并用右边对象的内容填充。

      theObjthree=theObjone;

      return 0;

      }

      也用到了"="号,但与"一、"中的例子并不同,"一、"的例子中,"="在对象声明语句中,表示初始化。更多时候,这种初始化也可用括号表示。

      例如 CExample theObjone(theObjtwo);

      而本例子中,"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree;,这其中涉及到对象theObjthree原有内容的丢弃,新内容的复制。

      但"="的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。

      由于对象内包含指针,将造成不良后果:指针的值被丢弃了,但指针指向的内容并未释放。指针的值被复制了,但指针所指内容并未复制。

      因此,包含动态分配成员的类除提供拷贝构造函数外,还应该考虑重载"="赋值操作符号。

      类定义变为:

      class CExample

      {

      ...

      CExample(const CExample&); //拷贝构造函数

      CExample& operator = (const CExample&); //赋值符重载

      ...

      };

      //赋值操作符重载

      CExample & CExample::operator = (const CExample& RightSides)

      {

      nSize=RightSides.nSize; //复制常规成员

      char *temp=new char[nSize]; //复制指针指向的内容

      memcpy(temp,RightSides.pBuffer,nSize*sizeof(char));

      delete []pBuffer; //删除原指针指向内容 (将删除操作放在后面,避免X=X特殊情况下,内容的丢失)

      pBuffer=NULL;

      pBuffer=temp; //建立新指向

      return *this

      }

     

      四、注意事项

      常见错误:

      拷贝构造函数使用赋值运算符重载的代码。

      CExample::CExample(const CExample& RightSides)

      {

      *this=RightSides //调用重载后的"="

      }

      而这样会造成循环调用重载后的"="和拷贝构造函数(因为对象以值传递的方式传入函数体会调用拷贝构造函数),最后造成栈溢出(Stack Overflow)。 

     

     ****分析*********************************************

       1、 拷贝构造函数不可以改变它所引用的对象,其原因如下:当一个对象以传递值的方式传入函数的时候,拷贝构造函数自动的被调用来生成函数中的对象(如果拷贝函数可以改变并且改变了引用对象,则创建的新对象与引用对象不一致,未能达到拷贝目的)。

       2、如果一个对象是被传入自己的拷贝构造函数,它的拷贝构造函数将会被调用来拷贝这个对象这样复制才可以传入它自己的拷贝构造函数,这会导致无限循环直至栈溢出(Stack Overflow)。除了当对象传入函数的时候被隐式调用以外,拷贝构造函数在对象被函数返回的时候也同样的被调用。

     **************************************************

    展开全文
  • 拷贝构造函数:属于特殊的构造函数,同一个类的A对象构造和初始化B对象。二、什么时候用拷贝构造函数? 在C++中,拷贝构造函数将会适用在下面三种情况。 1、一个对象以值传递的方式传入函数。 2、一个对象以值...

    一、基本概念
    构造函数:属于特殊的类成员函数,为数据成员初始化和分配内存。
    拷贝构造函数:属于特殊的构造函数,同一个类的A对象构造和初始化B对象。

    二、什么时候用拷贝构造函数?
    在C++中,拷贝构造函数将会适用在下面三种情况。
    1、一个对象以值传递的方式传入函数。
    2、一个对象以值传递的方式从函数返回。
    3、一个对象需要通过另一个对象进行初始化。


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

    class Rectangle
    {
    public:
        Rectangle() //构造函数
        {
        }
        Rectangle(const Rectangle& Other) //拷贝构造函数
        {
            height=Other.height;
            width =Other.width;
        }
        ~Rectangle() //析构函数
        {
        }
    private:
        int width;
        int height;
    };
    //定义一个全局函数Func
    void Func(Rectangle Rect)
    {
        printf("一个对象以值传递的方式传入函数\n");
    }
    
    int main()
    {
        Rectangle Rectangle1;
        Func(Rectangle1);
        return 0;
    }

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

    class Rectangle
    {
    public:
        Rectangle(int a,int b) //构造函数
        {
            width = a;
            height = b;
        }
        Rectangle(const Rectangle& Other) //拷贝构造函数
        {
            height=Other.height;
            width =Other.width;
        }
        ~Rectangle() //析构函数
        {
        }
    public:
        int width;
        int height;
    };
    //定义一个全局函数Func
    Rectangle Func()
    {
        Rectangle Rect(5,3);
        printf("width:%d,height:%d\n",Rect.width,Rect.height);
        return Rect;
    }
    
    int main()
    {
        Func();
        return 0;
    }

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

    class Rectangle
    {
    public:
        Rectangle(int a,int b) //构造函数
        {
            width = a;
            height = b;
        }
        Rectangle(const Rectangle& Other) //拷贝构造函数
        {
            height=Other.height;
            width =Other.width;
        }
        ~Rectangle() //析构函数
        {
        }
    private:
        int width;
        int height;
    };
    
    int main()
    {
        Rectangle Rectangle1(5,3);
        Rectangle Rectangle2(Rectangle1);
        return 0;
    }

    三、浅拷贝/深拷贝
    1、浅拷贝
    如果在类中没有声明拷贝构造函数时,编译器会自动生成一个默认的拷贝构造函数。如果类中无指针等动态成员时,我们自定义的拷贝构造函数通常为浅拷贝。

    2、深拷贝
    类中有指针等动态成员时,就不能简单地赋值了,而应重新动态分配空间。
    原因在于:当类中使用了指针时,两个对象的析构函数将对p指向的同一块内存空间释放两次,导致运行错误(编译器调用一次构造函数,两次析构函数)。
    解决办法就是使用深拷贝,将指针P的地址重新动态分配,但保留指针指向相同的数值。

    class Rectangle
    {
    public:
        Rectangle() //构造函数
        {
            p = new int(100);
        }
        Rectangle(const Rectangle& Other) //拷贝构造函数
        {
            height=Other.height;
            width =Other.width;
            p = new int;  //重新动态分配内存
            *p = *(Other.p);
        }
        ~Rectangle() //析构函数
        {
            if (p !=NULL)
            {
                delete p;
            }
        }
    private:
        int width;
        int height;
        int *p;
    };
    
    
    int main()
    {
        Rectangle Rectangle1;
        Rectangle Rectangle2(Rectangle1);
        return 0;
    }
    展开全文
  • C++基础---浅层及深层拷贝构造函数

    千次阅读 2015-09-04 15:59:03
    1. 浅层及深层拷贝构造函数 1.1 拷贝构造函数的定义 拷贝构造函数:又称复制构造函数,是一种特殊的构造函数; 拷贝构造函数:由编译器调用来完成一些基于同一类的其他对象的构建及初始化; 拷贝构造函数:唯一的...

    1. 浅层及深层拷贝构造函数

    1.1 拷贝构造函数的定义

    • 拷贝构造函数:又称复制构造函数,是一种特殊的构造函数;
    • 拷贝构造函数:由编译器调用来完成一些基于同一类的其他对象的构建及初始化
    • 拷贝构造函数:唯一的形参必须是引用,但并不限制为const,一般普遍的会加上const限制;
    • 拷贝构造函数:经常用在函数调用时用户定义类型的值传递及返回;
    • 拷贝构造函数:要调用基类的拷贝构造函数和成员函数;
    • 拷贝构造函数:如果可以的话,它将用常量方式调用,另外,也可以用非常量方式调用;
    • 拷贝构造函数:是由普通构造函数和赋值操作符共同实现的;

    1.2 拷贝构造函数的调用情形

    • 在C++中,下面三种对象需要调用拷贝构造函数:
      (1)一个对象作为函数参数,以值传递的方式传入函数体;
      (2)一个对象作为函数返回值,以值传递的方式从函数返回;
      (3)一个对象用于给另外一个对象进行初始化(常称为赋值初始化);

    1.3 默认拷贝构造函数

    • 编译器提供了默认构造函数和析构函数,编译器同样也提供了默认拷贝构造函数
    • 但编译器提供的默认拷贝构造函数只是把传递进来的对象的每个成员复制到新对象的成员变量中去
    • 两个对象中的变量均指向存放类成员变量的那块内存区域
    • 定义形式:A(const A &a);

    1.4 浅层拷贝构造函数

    • 由于编译器提供的默认拷贝构造函数只是把传递进来的对象的每个成员复制到新对象的成员变量中去。
    • 两个对象中的变量均指向存放类成员变量的那块内存区域,我们把这种拷贝叫浅层拷贝。
    • 假如该变量不是指针变量,一般不会立即出错;
    • 假如该变量是指针变量时,当这两个对象中的任何一个超出作用域时,都会出现知名的错误,产生迷途指针。
    • 比如,将对象a删除,那么析构函数会自动释放堆中存放的那块内存空间,而对象b的指针变量x仍指向该内存空间,由于该空间已经不在,那么对象b的指针变量x现在就变成了一个迷途指针,该程序处于崩溃边缘。
    • 代码示例:

      
      #include <iostream> 
      
      using namespace std;
      class A
      {
      public:
          A()
          {
              x = new int;
              *x = 5;
          }
          ~A()
          {
              delete x;
              x=NULL;
          }
          A(const A &a)
          {
              cout<<"拷贝构造函数执行..."<<endl;
              x = a.x;
          }
          int print()const
          {
              return *x;
          }
          void set(int i)
          {
              *x = i;
          }
      private:
          int *x;
      };
      int main()
      {
          A *a = new A();
          cout<<"a: "<<a->print()<<endl;
          A b = (*a);//调用拷贝构造函数
          a->set(32);
          cout<<"b: "<<b.print()<<endl;
          b.set(99);
          cout<<"a: "<<a->print()<<endl;
          //delete a;
          system("pause");
          return 0;
      }
      =>a:5
        拷贝构造函数执行...
        b:32
        a:99

      注:假如将上述例子中的delete a;语句打开注释,程序立马崩溃,对象b中的指针成员变量x仍然指向已经释放的内存空间,对象b中的指针成员变量x成了迷途指针。

    1.5 深层拷贝构造函数

    • 为了解决浅层拷贝导致的迷途指针的问题,必须创建自己的拷贝构造函数,并且在函数中为成员变量分配内存
    • 这样,在分配完内存后,旧对象的成员变量就可以复制到新的内存区域中。
    • 两个对象的成员变量都各自拥有自己的内存区域
    • 代码示例:

      
      #include <iostream> 
      
      using namespace std;
      class A
      {
      public:
          A()
          {
              x = new int;
              *x = 5;
          }
          ~A()
          {
              delete x;
              x=NULL;
          }
          A(const A &a)
          {
              cout<<"拷贝构造函数执行..."<<endl;
              //x = a.x;
              x = new int;//开辟新的空间,复制构造对象的同时将成员指针变量保存在新空间中
              *x = *(a.x);//读取旧对象的成员指针变量x地址处的数据并赋值给新对象的成员指针变量x所指向的内存区域
          }
          int print()const
          {
              return *x;
          }
          void set(int i)
          {
              *x = i;
          }
      private:
          int *x;
      };
      int main()
      {
          A *a = new A();
          cout<<"a: "<<a->print()<<endl;
          A b = (*a);
          a->set(32);
          cout<<"b: "<<b.print()<<endl;
          b.set(99);
          cout<<"a: "<<a->print()<<endl;
          delete a;
          system("pause");
          return 0;
      }
      =>a:5
        拷贝构造函数执行...
        b:5
        a:32

      注:此时,打开delete a;语句的注释不会奔溃,是由于两个对象指向的内存空间不是一样的了,因此可以独立释放内存空间,不会影响到另一个对象。


    参考文献:
    [1]《C++全方位学习》范磊——第十章
    [2]《C++程序设计教程(第二版)》钱能——第五章、第六章、第七章
    [3]《C++ Primer(第5版)》王刚 杨巨峰——第一章、第六章
    [4] 百度搜索关键字:C++函数、构造函数、拷贝构造函数、浅层拷贝构造函数、深层拷贝构造函数

    展开全文
  • 拷贝构造函数是用于将一个对象复制到新创建的对象中。 浅拷贝只是复制了对象的引用地址,两个对象指向同一个内存地址,所以修改其中任意的值,另一个值都会随之变化,这就是浅拷贝 深拷贝是将对象及值复制过来,两个...
  • 当对一个已知对象进行拷贝时,编译系统会自动调用一种构造函数 —— 拷贝构造函数,如果用户未定义拷贝构造函数,则会调用默认拷贝构造函数。 #include <iostream> using namespace std; class Student {...
  • 拷贝构造函数

    2018-09-14 07:44:59
    如果对象的成员变量确实引用了外部资源(在堆区申请过空间),必须实现深拷贝构造函数而不能去依赖编译器为我们自动生成的浅拷贝构造函数。 拷贝构造函数必须传入对象的引用或指针,不可以传入对象本身。 否则会...
  • 一、拷贝构造函数 功能:使用一个已经存在的对象来初始化一个新的同一类型的对象 声明:只有一个参数并且参数为该类对象的引用 注意:如果类中没有说明拷贝构造函数,则系统自动生成一个缺省复制构造函数,作为该类...
  • 拷贝构造函数,默认拷贝构造函数 1.c++的默认拷贝构造函数,从深度拷贝和浅拷贝说起 c++类的默认拷贝构造函数的弊端 c++类的中有两个特殊的构造函数,(1)无参构造函数,(2)拷贝构造函数。它们的特殊之处在于: (1)...
  • 拷贝构造函数是一种特殊的构造函数,函数的名称必须和类名称一致,它必须的一个参数是本类型的一个引用变量。 作用就是用来复制对象,在使用这个对象的实例来初始化这个对象的一个新的实例。类中可以存在多个拷贝...
  • 何为拷贝构造函数? 一般一个构造函数的参数是自身类类型的const引用,则这个构造函数就是拷贝构造函数拷贝构造函数是被用来初始化 非引用类 类型参数, 参数必须是引用类型。 如: class MyString {  ...
  • #include <iostream> #include <string> using namespace std; class student { private: char *m_name; int m_age;... //构造函数(如果不写构造函数,系统会调用默认构造函数) stud...
  • 一:拷贝构造函数 拷贝构造函数是一种特殊的构造函数,遵循如下的规则: 1.函数名和类名一致,没有返回值。 2.必须有一个参数,参数是本类型的一个引用变量。 3.拷贝构造函数可以访问参数对象的任意成员(private...
  • 拷贝构造函数是一种特殊的构造函数,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数常用于: 通过使用另一个同类型的对象来初始化新创建的对象; 复制对象把它作为参数传递给...
  • 拷贝构造函数是一种特殊的构造函数,用于在一个同类型对象的基础上生成一个新对象,他的函数形参列表有固定的写法(常量引用的形式)。 以二叉树节点的类Node为例: class Node { public: int index; Node* ...
  • 拷贝构造函数(深拷贝vs浅拷贝)

    千次阅读 2014-10-12 09:46:57
    拷贝构造函数(深拷贝vs浅拷贝) 类对象之间的初始化是由类的拷贝构造函数完成的。它是一种特殊的构造函数,它的作用是用一个已知的对象来初始化另一个对象。如果在类中没有显式地声明一个拷贝构造函数,那么,编译器...
  • 一,拷贝构造函数 拷贝构造函数是一种特殊的构造函数,函数的名称必须和类名称一致,它的唯一的一个参数是本类型的一个引用变量,该参数是const类型,不可变的。例如:类X的拷贝构造函数的形式为X(const X& x)...
  • 构造函数与拷贝构造函数

    千次阅读 多人点赞 2019-04-03 09:07:15
    拷贝构造函数和构造函数不能分开说,他们都是初始化对象的一种方法。但是我们这里用构造函数辅助说明拷贝构造函数,主要说说拷贝构造函数的声明,用途和使用注意事项。 众所周知,构造函数是一个初始化类对象的函数...
  • 详细讲解了拷贝构造函数深拷贝和浅拷贝以及之间的区别。
  • 在介绍C++浅拷贝与深拷贝之前,我们先引出C++的拷贝构造函数。  C++拷贝构造函数是一种特殊的构造函数,其形参是本类对象的引用。用于在建立一个新的对象时,使用一个已经存在的对象来初始化这个新对象。因为拷贝...
  • C++提供了默认拷贝构造函数: class C { private: int a; public: C(const C& c) {a = c.a;} }默认的拷贝构造函数是将类中的成员全部复制一遍,但是当类中的成员为指针一类的资源时,拷贝的是指针本身,而资源...
  • 拷贝构造函数深拷贝例子

    千次阅读 2018-08-03 09:54:32
    1.拷贝构造函数也是一个构造函数,用来构造对象,只有在对象定义时起作用,其第一个参数是自身类型的引用,其他任何参数均带有默认值.(如果第一个参数不是引用类型,因为构造拷贝对象时必须调用拷贝构造函数,那么...
  • 构造函数是干什么的该类对象被创建时,编译系统对象分配内存空间,并自动调用该构造函数,由构造函数完成成员的初始化工作,故:构造函数的作用:初始化对象的数据成员。构造函数的种类 1 class Complex 2 { 3 ...
  • 1.拷贝构造函数 首先,简单介绍一下拷贝构造函数拷贝构造函数是构造函数的一种,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。 拷贝构造函数将创建好(已初始化)的对象作为参数,返回一...
  • 构造函数为类对象分配内存空间。...拷贝构造函数是对象正确初始化的重要保证 必要时,必须手工编写拷贝构造函数 class Demo { public: Demo() { //无参数构造函数 a = 0; b = 0; p ...
  • 其次,介绍一下什么是拷贝构造函数以及拷贝构造函数将在何时被调用? 拷贝构造函数是一种特殊的构造函数,其形参是本类对象的引用,其作用是使用一个已经存在的对象来初始化 一个新的同类的对象。 何时被调用? ...
  • C++ 拷贝构造函数 赋值构造函数 拷贝构造函数和赋值构造函数的异同
  • 拷贝构造函数是一种特殊的构造函数,其形参是本类对象的引用。其作用是使用一个已经存在的对象去初始化另一个同类的对象。 说明 1.在定义时通过等于号复制对象时,系统会自动调用拷贝构造函数。(注意,不是在任何...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,355
精华内容 24,942
关键字:

深拷贝构造函数