精华内容
下载资源
问答
  • 什么时候用拷贝构造函数,和赋值构造函数:    (一)当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就会被自动调用。也就是说,当类的对象需要拷贝时,拷贝构造函数将...

    什么时候用拷贝构造函数,和赋值构造函数: 

     
    (一)当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就会被自动调用。也就是说,当类的对象需要拷贝时,拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数: 
    一个对象以值传递的方式传入函数体 
    一个对象以值传递的方式从函数返回 
    一个对象需要通过另外一个对象进行初始化。 
        如果在类中没有显式地声明一个拷贝构造函数,那么,编译器将会自动生成一个默认的拷贝构造函数,该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝,后面将进行说明。 
        自定义拷贝构造函数是一种良好的编程风格,它可以阻止编译器形成默认的拷贝构造函数,提高源码效率。 
    例子: 
    String a("hello"); 
    String b("world"); 
    String c = a; // 调用了拷贝构造函数,最好写成 c(a); 
    c = b; // 调用了赋值构造函数。! 
    本例中第三个语句的风格较差,宜改写成String c(a) 以区别于第四个语句。 
    (二)拷贝构造函数是在对象被创建时调用的,而赋值函数只能被已经存在了的对象调用。 
    不同点: 
    拷贝构造函数首先是一个构造函数,它调用的时候产生一个对象,是通过参数传进来的那个对象来初始化,产生的对象。  
    operator=();是把一个对象赋值给一个原有的对象,所以如果原来的对象中有内存分配要先把内存释放掉,而且还要检查一下两个对象是不是同一个对象,如果是的话就不做任何操作。 
    还要注意的是拷贝构造函数是构造函数,不返回值;而赋值函数需要返回一个对象自身的引用,以便赋值之后的操作。

    浅拷贝和深拷贝 
    在某些状况下,类内成员变量需要动态开辟堆内存,如果实行位拷贝,也就是把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。 
        深拷贝和浅拷贝的定义可以简单理解成:如果一个类拥有资源(堆,或者是其它系统资源),当这个类的对象发生复制过程的时候,这个过程就可以叫做深拷贝,反之对象存在资源,但复制过程并未复制资源的情况视为浅拷贝。 
        浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

    下面是例子,注意看两种函数怎么写,什么地方用到:

    #include <iostream>
    using namespace std;
    class CA
    {
      public:
        CA(int b,char* cstr)
        {
          a=b;
          str=new char[b];
          strcpy(str,cstr);
        }
        CA(const CA& Other)                    //拷贝构造函数
        {
          a=Other.a;
          str=new char[a]; //深拷贝
          if(str!=0)
            strcpy(str,Other.str);
        }
     
        CA & operator = (const CA& Other)    //赋值符重载
        {
            a=Other.a;    //复制常规成员
            // (1) 检查自赋值
            if(this == &Other)
            return *this;
            // (2) 释放原有的内存资源
            delete [] str;
            // (3) 分配新的内存资源,并复制内容
            str = new char[a];
            strcpy(str,Other.str);
            // (4) 返回本对象的引用
            return *this;
        }
        void Show()
        {
          cout<<str<<endl;
        }
        ~CA()
        {
          delete str;
        }
      private:
        int a;
        char *str;
    };
    int main()
    {
      CA A(10,"Hello!");
      CA B=A;
      B.Show();
      CA C(9,"world!");
      C = B;
      return 0;
    } 

    下面是另外一个例子,修改了下里面的赋值构造函数,把temp变量去掉了,这样更省空间吧?

    class CExample
    {
        ...
        CExample(const CExample&); //拷贝构造函数
        CExample& operator = (const CExample&); //赋值符重载
        ...
    };
     
    //拷贝构造函数使用赋值运算符重载的代码。
    CExample::CExample(const CExample& RightSides)
    {
        pBuffer=NULL;
        *this=RightSides     //调用重载后的"="
    }
     
    //赋值操作符重载
    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=temp;   //建立新指向
        return *this
    }
    //其实也没啥改进,但觉得这样的写法是不是更好?省了一个temp临时变量。
    CExample & CExample::operator = (const CExample& RightSides)
    {
        nSize=RightSides.nSize; //复制常规成员
     
        delete []pBuffer; //删除原指针指向内容  (将删除操作放在后面,避免X=X特殊情况下,内容的丢失)
        pBuffer=new char[nSize];   //建立新指向
        memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char));
        return *this
    }

    展开全文
  • 拷贝构造函数 都是在什么情况下调?... 什么时候调用拷贝构造函数 ** */ #include using namespace std; //日期类 class Date{ public: int year,month,day; Date(){//无参构造 cout 日期类的构造函数" <<



    拷贝构造函数 都是在什么情况下调用???


    /*
     **
         什么时候调用拷贝构造函数
     **
     */
    
    #include <iostream>
    using namespace std;
    
    
    //日期类
    class Date{
        
    public:
        int year,month,day;
        Date(){//无参构造
            cout << "日期类的构造函数" << endl;
        }
        
        ~Date(){
            cout << "日期的析构函数" << endl;
        }
       
    #pragma 拷贝构造函数里面的参数类型必须是引用
        Date (const Date& d3){
            this->year = d3.year;
            this->month = d3.month;
            this->day = d3.day;
            cout << "拷贝构造函数Date (Date& d3)" << endl;
            
        }
        
    };
    
    
    void fa(Date d){//在这个参数可以看出会创建一个新的临时变量d对象,相当于Date d = d;后面的d是传进来的,也就是通过相同类型对象来创建对象,所以这里会调用拷贝构造函数。
        
    }
    
    //主函数
    int main(){
        Date d;
        cout << "===== 1 =====" << endl;
        
        fa(d);
        
        cout << "===== 2 =====" << endl;
        return 0;
    }


    运行结果:

    日期类的构造函数
    ===== 1 =====
    拷贝构造函数Date (Date& d3)   //fa函数进栈
    日期的析构函数                 //弹栈
    ===== 2 =====
    日期的析构函数
    Program ended with exit code: 0

    再写一个参数是引用类型的函数 fb 如下:

    void fb(Date &d){ //这里是给传进的参数创建别名(引用)不会创建新的对象
        
    }

    修改主函数如下:

    /主函数
    int main(){
        Date d;
        cout << "===== 1 =====" << endl;
        
        fa(d);
        
        cout << "===== 2 =====" << endl;
        
        fb(d);
        cout << "===== 3 =====" << endl;
        return 0;
    }

    运行结果可以看出在2和3之间并没有创建新的对象


    日期类的构造函数
    ===== 1 =====
    拷贝构造函数Date (Date& d3)
    日期的析构函数
    ===== 2 =====
    ===== 3 =====
    日期的析构函数
    Program ended with exit code: 0


    再创建一个参数类型是指针类型的函数 fc 如下:

    void fc(Date *d){ //传进来的参数是指针类型
        //这里创建了一个指针变量放在栈里面了,但是没有创建新的对象,指针指向的是传进来的对象的地址
    }

    主函数如下:

    //主函数
    int main(){
        Date d;
        cout << "===== 1 =====" << endl;
        
        fa(d);
        
        cout << "===== 2 =====" << endl;
        
        fb(d);
        cout << "===== 3 =====" << endl;
        fc(&d);
        cout << "===== 4 =====" << endl;
        return 0;
    }

    运行的结果如下:

    日期类的构造函数
    ===== 1 =====
    拷贝构造函数Date (Date& d3)
    日期的析构函数
    ===== 2 =====
    ===== 3 =====
    ===== 4 =====
    日期的析构函数
    从运行结果3和4之间也可以知道并没有创建新的对象。


    再来,创建一个返回值类型是Date ,参数是引用类型的函数 fd 如下:

    Date fd(Date &r){
        return r;
    }

    主函数中:

    //主函数
    int main(){
        Date d;
        cout << "===== 1 =====" << endl;
        fa(d);
        cout << "===== 2 =====" << endl;
        fb(d);
        cout << "===== 3 =====" << endl;
        fc(&d);
        cout << "===== 4 =====" << endl;
        fd(d);
        cout << "===== 5 =====" << endl;
        
        return 0;
    }

    运行结果如下:

    日期类的构造函数
    ===== 1 =====
    拷贝构造函数Date (Date& d3)
    日期的析构函数
    ===== 2 =====
    ===== 3 =====
    ===== 4 =====
    拷贝构造函数Date (Date& d3)
    日期的析构函数
    ===== 5 =====
    日期的析构函数
    Program ended with exit code: 0


    从运行结果可知在4和5之间调用了拷贝构造函数创建对象了。那fd这个函数哪里创建对象了呢?  参数是引用类型,只是起别名,所以并没有创建对象。是返回值这里创建了,返回值类型是Date类型,相当于通过引用 Date = r ;创建了一个匿名的临时对象,所以这里会调用拷贝构造函数。


    如果main主函数中修改如下,结果会如何呢?

        cout << "===== 4 =====" << endl;
        Date d2 = fd(d);                      
        cout << "===== 5 =====" << endl;
        

    理论上fd(d); 这里有一个拷贝构造函数和一个析构函数  还有这一步Date d2 = fd(d);  这里应该还有一个拷贝构造函数


    运行结果如下:


    日期类的构造函数
    ===== 1 =====
    拷贝构造函数Date (Date& d3)
    日期的析构函数
    ===== 2 =====
    ===== 3 =====
    ===== 4 =====
    拷贝构造函数Date (Date& d3)
    ===== 5 =====
    日期的析构函数
    日期的析构函数
    Program ended with exit code: 0

    为什么运行结果和我们分析的理论不一样呢??45之间为什么不是2个拷贝构造函数和1个析构函数呢?(其中一个拷贝构造函数和析构函数是fd的返回值临时变量的)

    那是因为编译器做的优化,它把那个临时变量的拷贝构造函数和析构函数相抵消了,所以这里也就只显示了 Date d2 = ...这个的拷贝构造函数。



    再写一个返回值是引用类型  参数是引用类型的函数 fe:

    Date& fe(Date &r){
        return r;
    }

    主函数中添加如下代码:
        <p class="p1"><span class="s1">    cout</span><span class="s2"> << </span><span class="s3">"===== 5 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p><p class="p2"><span class="s5">    </span><span class="s6">fe</span><span class="s5">(d);</span><span class="s7">//</span><span class="s3">参数</span><span class="s7"> </span><span class="s3">返回值都是引用类型的函数</span></p><p class="p1"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 6 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p><p class="p3"><span class="s3">    </span><span class="s8">Date</span><span class="s3"> d3 = </span><span class="s9">fe</span><span class="s3">(d);</span></p><p class="p1"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 7 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p><p class="p1"><span class="s1">    Date</span><span class="s2"> &d4 = </span><span class="s3">fe</span><span class="s2">(d);  //创建一个引用变量接收函数返回的</span></p><p class="p2"><span class="s4">    </span><span class="s5">cout</span><span class="s4"> << </span><span class="s2">"===== 8 ====="</span><span class="s4"> << </span><span class="s6">endl</span><span class="s4">;</span></p>
        

    运行结果如下:
    日期类的构造函数
    ===== 1 =====
    拷贝构造函数Date (Date& d3)
    日期的析构函数
    ===== 2 =====
    ===== 3 =====
    ===== 4 =====
    拷贝构造函数Date (Date& d3)
    ===== 5 =====
    ===== 6 =====
    拷贝构造函数Date (Date& d3)
    <p class="p1"><span class="s1">===== 7 =====</span></p><p class="p1"><span class="s1">===== 8 =====</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p3"><span class="s1">Program ended with exit code: 0</span></p>

    从运行结果可知56之间的只是调用函数fe  ,该函数的返回值和参数都是引用类型,并没有创建新的对象。
       而在67之间因为通过返回值创建了对象 Date d3 =......这里调用了拷贝构造函数。
       而78之间因为创建一个引用类型的变量来接收函数返回的,也就是相当于起别名,而并没有创建新对象,所以并没有调用拷贝构造函数




    再来,在main函数当中添加如下代码:
        cout << "===== 8 =====" << endl;
        Date d5[2] = {d,d2};              //数组里面有2个元素,分别用d和d2来赋值
        <span class="s1" style="font-family: Arial, Helvetica, sans-serif;">cout</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s3" style="font-family: Arial, Helvetica, sans-serif;">"===== 9 ====="</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s4" style="font-family: Arial, Helvetica, sans-serif;">endl</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;">;</span><p class="p2"><span class="s3">    </span><span class="s5">Date</span><span class="s3"> d6[</span><span class="s6">5</span><span class="s3">];</span></p><p class="p1"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 10 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p>
    运行结果如下:

    <p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 1 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 2 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 3 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 4 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 5 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 6 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 7 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 8 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 9 =====</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 10 =====</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p3"><span class="s1"><span style="font-size:18px;">Program ended with exit code: 0</span></span></p>

    在结果89之间看到有2个拷贝构造函数。因为是通过同类型对象来创建对象的,所以会调用2个拷贝构造函数。
    在9和10 之间会看到5个构造函数,这里不是拷贝构造而是直接创建对象,所以是构造函数。



    如果再在main函数里面添加如下的代码:
    <span style="font-size:24px;">    </span><span style="font-size:18px;"><span class="s1" style="font-family: Arial, Helvetica, sans-serif;">cout</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s3" style="font-family: Arial, Helvetica, sans-serif;">"===== 10 ====="</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s4" style="font-family: Arial, Helvetica, sans-serif;">endl</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;">;</span></span><p class="p2"><span style="font-size:18px;"><span class="s3">    d = d2;  </span><span class="s5">//</span><span class="s6">赋值操作</span></span></p><p class="p1"><span style="font-size:18px;"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 11 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s3">    </span><span class="s7">Date</span><span class="s3"> *d7 = </span><span class="s8">new</span><span class="s3"> </span><span class="s7">Date</span><span class="s3">;</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s3"></span></span></p><p class="p1"><span style="font-size:18px;"><span class="s1">    delete</span><span class="s2"> d7;</span></span></p><p></p><p class="p1"><span style="font-size:18px;"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 12 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></span></p>
    运行结果:
    <p class="p1"><span class="s1">===== 10 =====</span></p><p class="p1"><span class="s1">===== 11 =====</span></p><p class="p2"><span class="s1">日期类的构造函数</span></p><p class="p2"><span class="s1"></span></p><p class="p1"><span class="s1">日期的析构函数</span></p><p></p><p class="p1"><span class="s1">===== 12 =====</span></p>

    运行结果10 和 11之间什么都没有打印,也就是并没有创建新的对象。
    而11和12之间只有一个构造函数,Date *d7是指针,指向一个对象,在创建这个对象的时候就调用了构造函数。

    如果把11和12当中 delete d7注释掉  然后通过d7来创建对象,main函数中增加如下代码呢:
       cout << "===== 12 =====" << endl;
        Date *d8 = new Date(*d7);
        delete d8;
        cout << "===== 13 =====" << endl;
    运行结果如下:
    <p class="p1"><span class="s1">===== 12 =====</span></p><p class="p1"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p1"><span class="s1">===== 13 =====</span></p>

    在12和13之间是通过*d7得到同类型的对象然后创建对象,所以这里会调用拷贝构造函数。



    要搞明白:
    什么时候调用构造函数 ?   什么时候调用拷贝构造函数 ?  什么时候什么都不调用??





















    展开全文
  • 1、拷贝构造函数一个已存在的对象去初始化另一个需要新建的对象,即已经存在的对象初始化新建对象。 2、拷贝构造函数的写法类名 (const 类名 &amp;amp;要拷贝的类名) 例如: X是类的名称; X...

    1、拷贝构造函数是用一个已存在的对象去初始化另一个需要新建的对象,即用已经存在的对象初始化新建对象。
    2、拷贝构造函数的写法类名 (const 类名 &要拷贝的类名)
    例如:
    X是类的名称;

    X(const X &p)
    {
    a_=p.a_,b_=p.b_;//这里必须要有
    }
    

    2、使用拷贝构造函数的情形
    (1)

    X (const X &p){}
    int main()
    {X p2=p1;}
    

    (2)

    X (const X &p){}
    Line(Point &p):p1(p){}//这里调用了拷贝构造函数,前面没有调用拷贝构造函数,但是后面p1(p)这里调用了拷贝构造函数;
    int main()
    {
    Point p2(p1);//这里会调用拷贝构造函数;
    }
    

    (3)以对象来作为参数并且必须是传值参数

    X (const X &p){}
    void f(X p){}//这里是传值参数,所以调用拷贝构造函数;
    void f(X &p){}//不调用拷贝构造函数,因为都不生成新对象;
    void f(X *p){}//不调用拷贝构造函数,因为都不生成新对象;
    int main()
    {
    
    }
    

    (4)返回类对象时会调用拷贝构造函数

    X f1()
    {
        X p1(2,2);//对类的局部变量,p1在函数结束时释放,
        return p1;//不会调用拷贝构造函数
    }
    改法一:
    X f1()
    {
        statio X p1(1,2);
        return p1;
    }
    改法二:
    X p1(1,2);//全局变量;
    {
        return p1;
    }
    改法三:
    {
        X *p=new X(1,2);
        return *p;
    }
    综上以上三总方法是只要别释放掉即可;
    

    3、拷贝构造函数说明
    (1)拷贝构造函数与一般构造函数相同,与类同名,没有返回类型,可以重载。
    (2)把一个对象复制给一个已经定义好的对象时,调用的是赋值运算符函数。

    X p;
    X p1;
    p1=p;//这个时候因为P已经定义好了,所以调用的是赋值运算符函数;
    

    (3)第一个参数必须是自身类型的引用,其余参数必须有默认值。

    展开全文
  • //创建 cat2时系统自动调用拷贝构造函数cat1初始化cat2 2.类的一个对象初始化另一个对象时的另外一种形式 cat cat2=cat1;//注意并非 cat cat1,cat2;cat2=cat1; 3.对象作为函数参数传递时 f(cat a){} cat b...

    1.用类的一个对象初始化另一个对象

    cat cat1;
    cat cat2(cat1);//创建 cat2时系统自动调用拷贝构造函数,用cat1初始化cat2
    
    

    2.用类的一个对象初始化另一个对象时的另外一种形式

    cat cat2=cat1;//注意并非 cat cat1,cat2;cat2=cat1;
    
    

    3.对象作为函数参数传递时

    f(cat a){}
    cat b;
    f(b);//进行f函数调用时,系统自动调用拷贝构造函数
    

    4.函数的返回值是类的对象,函数调用返回时,调用拷贝构造函数

    cat f(){cat a;...return a;}     //返回值为cat类
    cat b;                          //定义对象 b
    b=f();                          //调用f函数,系统自动调用拷贝构造函数
    
    
    展开全文
  • 二、什么时候用拷贝构造函数? 在C++中,拷贝构造函数将会适用在下面三种情况。 1、一个对象以值传递的方式传入函数。 2、一个对象以值传递的方式从函数返回。 3、一个对象需要通过另一个对象进行初始化。1、一...
  • 什么时候用拷贝构造函数,和赋值构造函数: (一)当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就会被自动调用。也就是说,当类的对象需要拷贝时,拷贝构造函数将会被...
  • 1-什么时候会用到拷贝构造函数? 当任何你想复印东西的...隐式:函数的形参有用到类对象却没有用引用或传址技术时 函数的返回值是一个对象也没有应用传址技术时2-什么时候有必要用拷贝构造函数?上述3种情况,如果
  • 前提:当用户没有创建拷贝... 当Class具有Bitwise Copy属性时,直接memcpy内存拷贝,此时编译器不会合成拷贝构造函数。 总之,只要Class不具备Bitwise Copy属性,编译器就会合成拷贝构造函数。 没有Bitwise Co...
  • 1-什么时候会用到拷贝构造函数? 2-什么时候有必要手动写拷贝构造函数? 1-什么时候会用到拷贝构造函数? 当任何你想复印东西的时候,而不管东西被复印成什么样子。即任何你想利用一个已有的类实例给另一个...
  • 什么时候用拷贝构造函数,和赋值构造函数: (一)当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就会被自动调用。也就是说,当类的对象需要拷贝时,拷贝构造函数将会被...
  • 什么时候用拷贝构造函数,和赋值构造函数:  (一)当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就会被自动调用。也就是说,当类的对象需要拷贝时,拷贝构造函数将会被...
  • http://www.cnblogs.com/lionfight/archive/2012/05/25/2518631.html 什么时候用拷贝构造函数,和赋值构造函数:(一)当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就...
  • 拷贝构造函数

    2021-04-13 17:03:03
    一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候拷贝构造函数就会被自动调用。也就是说,当类的对象需要拷贝时,拷贝构造函数将会被调用。 以下情况都会调用拷贝构造函数: ① 程序中...
  • 1、构造函数实例化的对象进行构造int main() { Student a(10, 2); Student b = a; // 拷贝构造,并且要特别注意指针数据成员的赋值,避免出现野指针的情况 }2、返回临时对象(而不是返回对象的引用)rmb ...
  • 拷贝构造函数什么时候调用? 1当类的一个对象初始化该类的另一个对象时.例如: C/C++ code int main() { point A(1,2); point B(A);//对象A初始化对象B,拷贝构造函数被调用. } 2 如果...
  • 本文前面主要介绍了拷贝构造函数和赋值运算符函数的区别,以及在什么时候调用拷贝构造函数、什么情况下调赋值运算符函数。最后,分析了下深拷贝和浅拷贝的问题,即拷贝构造函数和赋值运算符函数的必要性和意义。 1...
  • 知识点拷贝构造函数的定义如果不自行写拷贝构造函数会怎样?默认拷贝构造函数浅拷贝和深拷贝 拷贝构造函数的定义 拷贝其实可以理解为复制,例如我们常见的整型数据之间的复制: int a = 5; int b = a; //a的值...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 263
精华内容 105
关键字:

什么时候用拷贝构造函数