精华内容
下载资源
问答
  • 复制构造函数是构造函数的一种,也称拷贝构造函数,它只有一个参数,参数类型是本类的引用。复制构造函数的参数可以是 const 引用,也可以是非 const 引用。 一般使用前者,这样既能以常量对象(初始化后值不能改变的...

    复制构造函数是构造函数的一种,也称拷贝构造函数,它只有一个参数,参数类型是本类的引用。

    复制构造函数的参数可以是 const 引用,也可以是非 const 引用。 一般使用前者,这样既能以常量对象(初始化后值不能改变的对象)作为参数,也能以非常量对象作为参数去初始化其他对象。一个类中写两个复制构造函数,一个的参数是 const 引用,另一个的参数是非 const 引用,也是可以的。

    如果类的设计者不写复制构造函数,编译器就会自动生成复制构造函数。大多数情况下,其作用是实现从源对象到目标对象逐个字节的复制,即使得目标对象的每个成员变量都变得和源对象相等。编译器自动生成的复制构造函数称为“默认复制构造函数”。

    注意,默认构造函数(即无参构造函数)不一定存在,但是复制构造函数总是会存在。

    下面是一个复制构造函数的例子。

    #include

    using namespace std;

    class Complex

    {

    public:

    double real, imag;

    Complex(double r, double i) {

    real= r; imag = i;

    }

    };

    int main(){

    Complex cl(1, 2);

    Complex c2 (cl); //用复制构造函数初始化c2

    cout<

    return 0;

    }

    第 13 行给出了初始化 c2 的参数,即 c1。只有编译器自动生成的那个默认复制构造函数的参数才能和 c1 匹配,因此,c2 就是以 c1 为参数,调用默认复制构造函数进行初始化的。初始化的结果是 c2 成为 c1 的复制品,即 c2 和 c1 每个成员变量的值都相等。

    如果编写了复制构造函数,则默认复制构造函数就不存在了。下面是一个非默认复制构造函数的例子。

    #include

    using namespace std;

    class Complex{

    public:

    double real, imag;

    Complex(double r,double i){

    real = r; imag = i;

    }

    Complex(const Complex & c){

    real = c.real; imag = c.imag;

    cout<

    }

    };

    int main(){

    Complex cl(1, 2);

    Complex c2 (cl); //调用复制构造函数

    cout<

    return 0;

    }

    程序的输出结果是:

    Copy Constructor called

    1,2

    第 9 行,复制构造函数的参数加不加 const 对本程序來说都一样。但加上 const 是更好的做法,这样复制构造函数才能接受常量对象作为参数,即才能以常量对象作为参数去初始化别的对象。

    第 17 行,就是以 c1 为参数调用第 9 行的那个复制构造函数初始化的。该复制构造函数执行的结果是使 c2 和 c1 相等,此外还输出Copy Constructor called。

    可以想象,如果将第 10 行删去或改成real = 2*c.real; imag = imag + 1;,那么 c2 的值就不会等于 c1 了。也就是说,自己编写的复制构造函数并不一定要做复制的工作(如果只做复制工作,那么使用编译器自动生成的默认复制构造函数就行了)。但从习惯上来讲,复制构造函数还是应该完成类似于复制的工作为好,在此基础上还可以根据需要做些別的操作。

    构造函数不能以本类的对象作为唯一参数,以免和复制构造函数相混淆。例如,不能写如下构造函数:

    Complex (Complex c) {...}

    复制构造函数被调用的三种情况

    复制构造函数在以下三种情况下会被调用。

    1) 当用一个对象去初始化同类的另一个对象时,会引发复制构造函数被调用。例如,下面的两条语句都会引发复制构造函数的调用,用以初始化 c2。

    Complex c2(c1);

    Complex c2 = c1;

    这两条语句是等价的。

    注意,第二条语句是初始化语句,不是赋值语句。赋值语句的等号左边是一个早已有定义的变量,赋值语句不会引发复制构造函数的调用。例如:

    Complex c1, c2; c1 = c2 ;

    c1=c2;

    这条语句不会引发复制构造函数的调用,因为 c1 早已生成,已经初始化过了。

    2) 如果函数 F 的参数是类 A 的对象,那么当 F 被调用时,类 A 的复制构造函数将被调用。换句话说,作为形参的对象,是用复制构造函数初始化的,而且调用复制构造函数时的参数,就是调用函数时所给的实参。

    #include

    using namespace std;

    class A{

    public:

    A(){};

    A(A & a){

    cout<

    }

    };

    void Func(A a){ }

    int main(){

    A a;

    Func(a);

    return 0;

    }

    程序的输出结果为:

    Copy constructor called

    这是因为 Func 函数的形参 a 在初始化时调用了复制构造函数。

    前面说过,函数的形参的值等于函数调用时对应的实参,现在可以知道这不一定是正确的。如果形参是一个对象,那么形参的值是否等于实参,取决于该对象所属的类的复制构造函数是如何实现的。例如上面的例子,Func 函数的形参 a 的值在进入函数时是随机的,未必等于实参,因为复制构造函数没有做复制的工作。

    以对象作为函数的形参,在函数被调用时,生成的形参要用复制构造函数初始化,这会带来时间上的开销。如果用对象的引用而不是对象作为形参,就没有这个问题了。但是以引用作为形参有一定的风险,因为这种情况下如果形参的值发生改变,实参的值也会跟着改变。

    如果要确保实参的值不会改变,又希望避免复制构造函数带来的开销,解决办法就是将形参声明为对象的 const 引用。例如:

    void Function(const Complex & c)

    {

    ...

    }

    这样,Function 函数中出现任何有可能导致 c 的值被修改的语句,都会引发编译错误。

    思考题:在上面的 Function 函数中,除了赋值语句,还有什么语句有可能改变 c 的值?例如,是否允许通过 c 调用 Complex 的成员函数?

    3) 如果函数的返冋值是类 A 的对象,则函数返冋时,类 A 的复制构造函数被调用。换言之,作为函数返回值的对象是用复制构造函数初始化 的,而调用复制构造函数时的实参,就是 return 语句所返回的对象。例如下面的程序:

    #include

    using namespace std;

    class A {

    public:

    int v;

    A(int n) { v = n; };

    A(const A & a) {

    v = a.v;

    cout << "Copy constructor called" << endl;

    }

    };

    A Func() {

    A a(4);

    return a;

    }

    int main() {

    cout << Func().v << endl;

    return 0;

    }

    程序的输出结果是:

    Copy constructor called

    4

    第19行调用了 Func 函数,其返回值是一个对象,该对象就是用复制构造函数初始化的, 而且调用复制构造函数时,实参就是第 16 行 return 语句所返回的 a。复制构造函数在第 9 行确实完成了复制的工作,所以第 19 行 Func 函数的返回值和第 14 行的 a 相等。

    需要说明的是,有些编译器出于程序执行效率的考虑,编译的时候进行了优化,函数返回值对象就不用复制构造函数初始化了,这并不符合 C++ 的标准。上面的程序,用 Visual Studio 2010 编译后的输出结果如上所述,但是在 Dev C++ 4.9 中不会调用复制构造函数。把第 14 行的 a 变成全局变量,才会调用复制构造函数。对这一点,读者不必深究。

    展开全文
  • 对于我来说,在写代码的时候能用得上复制构造函数的机会并不多,不过这并不说明复制构造函数没什么用,其实复制构造函数能解决一些我们常常会忽略的问题。为了说明复制构造函数作用,我先说说我们在编程时会遇到的...

    也许很多C++的初学者都知道什么是构造函数,但是对复制构造函数(copy constructor)却还很陌生。对于我来说,在写代码的时候能用得上复制构造函数的机会并不多,不过这并不说明复制构造函数没什么用,其实复制构造函数能解决一些我们常常会忽略的问题。

    为了说明复制构造函数作用,我先说说我们在编程时会遇到的一些问题。对于C++中的函数,我们应该很熟悉了,因为平常经常使用;对于类的对象,我们也很熟悉,因为我们也经常写各种各样的类,使用各种各样的对象;对于指针的操作,我们也不陌生吧?嗯,如果你还不了解上面三个概念的话,我想这篇文章不太适合你,不过看看也无碍^_^。我们经常使用函数,传递过各种各样的参数给函数,不过把对象(注意是对象,而不是对象的指针或对象的引用)当作参数传给函数的情况我们应该比较少遇见吧,而且这个对象的构造函数还涉及到一些内存分配的操作。嗯,这样会有什么问题呢?

    把参数传递给函数有三种方法,一种是值传递,一种是传地址,还有一种是传引用。前者与后两者不同的地方在于:当使用值传递的时候,会在函数里面生成传递参数的一个副本,这个副本的内容是按位从原始参数那里复制过来的,两者的内容是相同的。当原始参数是一个类的对象时,它也会产生一个对象的副本,不过在这里要注意。一般对象产生时都会触发构造函数的执行,但是在产生对象的副本时却不会这样,这时执行的是对象的复制构造函数。为什么会这样?嗯,一般的构造函数都是会完成一些成员属性初始化的工作,在对象传递给某一函数之前,对象的一些属性可能已经被改变了,如果在产生对象副本的时候再执行对象的构造函数,那么这个对象的属性又再恢复到原始状态,这并不是我们想要的。所以在产生对象副本的时候,构造函数不会被执行,被执行的是一个默认的构造函数。当函数执行完毕要返回的时候,对象副本会执行析构函数,如果你的析构函数是空的话,就不会发生什么问题,但一般的析构函数都是要完成一些清理工作,如释放指针所指向的内存空间。这时候问题就可能要出现了。假如你在构造函数里面为一个指针变量分配了内存,在析构函数里面释放分配给这个指针所指向的内存空间,那么在把对象传递给函数至函数结束返回这一过程会发生什么事情呢?首先有一个对象的副本产生了,这个副本也有一个指针,它和原始对象的指针是指向同块内存空间的。函数返回时,对象的析构函数被执行了,即释放了对象副本里面指针所指向的内存空间,但是这个内存空间对原始对象还是有用的啊,就程序本身而言,这是一个严重的错误。然而错误还没结束,当原始对象也被销毁的时候,析构函数再次执行,对同一块系统动态分配的内存空间释放两次是一个未知的操作,将会产生严重的错误。

    上面说的就是我们会遇到的问题。解决问题的方法是什么呢?首先我们想到的是不要以传值的方式来传递参数,我们可以用传地址或传引用。没错,这样的确可以避免上面的情况,而且在允许的情况下,传地址或传引用是最好的方法,但这并不适合所有的情况,有时我们不希望在函数里面的一些操作会影响到函数外部的变量。那要怎么办呢?可以利用复制构造函数来解决这一问题。复制构造函数就是在产生对象副本的时候执行的,我们可以定义自己的复制构造函数。在复制构造函数里面我们申请一个新的内存空间来保存构造函数里面的那个指针所指向的内容。这样在执行对象副本的析构函数时,释放的就是复制构造函数里面所申请的那个内存空间。

    除了将对象传递给函数时会存在以上问题,还有一种情况也会存在以上问题,就是当函数返回对象时,会产生一个临时对象,这个临时对象和对象的副本性质差不多。

    拷贝构造函数,经常被称作X(X&),是一种特殊的构造函数,他由编译器调用来完成一些基于同一类的其他对象的构件及初始化。它的唯一的一个参数(对象的引用)是不可变的(因为是const型的)。这个函数经常用在函数调用期间于用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话,它将用常量方式调用,另外,也可以用非常量方式调用。

    在C++中,下面三种对象需要拷贝的情况。因此,拷贝构造函数将会被调用。

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

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

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

    以上的情况需要拷贝构造函数的调用。如果在前两种情况不使用拷贝构造函数的时候,就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说,初始化和赋值的不同含义是构造函数调用的原因。事实上,拷贝构造函数是由普通构造函数和赋值操作赋共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。

    拷贝构造函数不可以改变它所引用的对象,其原因如下:当一个对象以传递值的方式传一个函数的时候,拷贝构造函数自动的被调用来生成函数中的对象。如果一个对象是被传入自己的拷贝构造函数,它的拷贝构造函数将会被调用来拷贝这个对象这样复制才可以传入它自己的拷贝构造函数,这会导致无限循环。

    除了当对象传入函数的时候被隐式调用以外,拷贝构造函数在对象被函数返回的时候也同样的被调用。换句话说,你从函数返回得到的只是对象的一份拷贝。但是同样的,拷贝构造函数被正确的调用了,你不必担心。

    如果在类中没有显式的声明一个拷贝构造函数,那么,编译器会私下里为你制定一个函数来进行对象之间的位拷贝(bitwise copy)。这个隐含的拷贝构造函数简单的关联了所有的类成员。许多作者都会提及这个默认的拷贝构造函数。注意到这个隐式的拷贝构造函数和显式声明的拷贝构造函数的不同在于对于成员的关联方式。显式声明的拷贝构造函数关联的只是被实例化的类成员的缺省构造函数除非另外一个构造函数在类初始化或者在构造列表的时候被调用。

    拷贝构造函数是程序更加有效率,因为它不用再构造一个对象的时候改变构造函数的参数列表。设计拷贝构造函数是一个良好的风格,即使是编译系统提供的帮助你申请内存默认拷贝构造函数。事实上,默认拷贝构造函数可以应付许多情况。

    附另外一篇关于复制构造函数的文章:

    对一个简单变量的初始化方法是用一个常量或变量初始化另一个变量,例如:

    int m = 80;

    int n = m;

    我们已经会用构造函数初始化对象,那么我们能不能象简单变量的初始化一样,直接用一个对象来初始化另一个对象呢?答案是肯定的。我们以前面定义的Point类为例:

    Point pt1(15, 25);

    Point pt2 = pt1;

    后一个语句也可以写成:

    Point pt2( pt1);

    它是用pt1初始化pt2,此时,pt2各个成员的值与pt1各个成员的值相同,也就是说,pt1各个成员的值被复制到pt2相应的成员当中。在这个初始化过程当中,实际上调用了一个复制构造函数。当我们没有显式定义一个复制构造函数时,编译器会隐式定义一个缺省的复制构造函数,它是一个内联的、公有的成员,它具有下面的原型形式:

    Point:: Point (const Point &);

    可见,复制构造函数与构造函数的不同之处在于形参,前者的形参是Point对象的引用,其功能是将一个对象的每一个成员复制到另一个对象对应的成员当中。

    虽然没有必要,我们也可以为Point类显式定义一个复制构造函数:

    Point:: Point (const Point &pt)

    {

    xVal=pt. xVal;

    yVal=pt. yVal;

    }

    如果一个类中有指针成员,使用缺省的复制构造函数初始化对象就会出现问题。为了说明存在的问题,我们假定对象A与对象B是相同的类,有一个指针成员,指向对象C。当用对象B初始化对象A时,缺省的复制构造函数将B中每一个成员的值复制到A的对应的成员当中,但并没有复制对象C。也就是说,对象A和对象B中的指针成员均指向对象C,实际上,我们希望对象C也被复制,得到C的对象副本D。否则,当对象A和B销毁时,会对对象C的内存区重复释放,而导致错误。为了使对象C也被复制,就必须显式定义复制构造函数。下面我们以string类为例说明,如何定义这个复制构造函数。

    class String

    {

    public:

    String(); //构造函数

    String(const String &s); //复制构造函数

    ~String(); //析构函数

    // 接口函数

    void set(char const *data);

    char const *get(void);

    private:

    char *str; //数据成员ptr指向分配的字符串

    };

    String ::String(const String &s)

    {

    str = new char[strlen(s.str) + 1];

    strcpy(str, s.str);

    }

    我们也常用无名对象初始化另一个对象,例如:

    Point pt = Point(10, 20);

    类名直接调用构造函数就生成了一个无名对象,上式用左边的无名对象初始化右边的pt对象。

    构造函数被调用通常发生在以下三种情况,第一种情况就是我们上面看到的:用一个对象初始化另一个对象时;第二种情况是当对象作函数参数,实参传给形参时;第三种情况是程序运行过程中创建其它临时对象时。下面我们再举一个例子,就第二种情况和第三种情况进行说明:

    Point foo(Point pt)

    {

    return pt;

    }

    void main()

    {

    Point pt1 = Point(10, 20);

    Point pt2;

    pt2=foo(pt);

    }

    在main函数中调用foo函数时,实参pt传给形参pt,将实参pt复制给形参pt,要调用复制构造函数,当函数foo返回时,要创建一个pt的临时对象,此时也要调用复制构造函数。

    缺省的复制构造函数  在类的定义中,如果没有显式定义复制构造函数,C++编译器会自动地定义一个缺省的复制构造函数。下面是使用复制构造函数的一个例子:

    例10-12

    #include

    #include

    class withCC

    {

    public:

    withCC(){}

    withCC(const withCC&)

    {

    cout<

    }

    };

    class woCC

    {

    enum{bsz = 100};

    char buf[bsz];

    public:

    woCC(const char* msg = 0)

    {

    memset(buf, 0, bsz);

    if(msg) strncpy(buf, msg, bsz);

    }

    void print(const char* msg = 0)const

    {

    if(msg) cout<

    cout<

    }

    };

    class composite

    {

    withCC WITHCC;

    woCC WOCC;

    public:

    composite() : WOCC("composite()"){}

    void print(const char* msg = 0)

    {

    WOCC.print(msg);

    }

    };

    void main()

    {

    composite c;

    c.print("contents of c");

    cout<

    composite c2 = c;

    c2.print("contents of c2");

    }   类withCC有一个复制构造函数,类woCC和类composite都没有显式定义复制构造函数。如果在类中没有显式定义复制构造函数,则编译器将自动地创建一个缺省的构造函数。不过在这种情况下,这个构造函数什么也不作。

    类composite既含有withCC类的成员对象又含有woCC类的成员对象,它使用无参的构造函数创建withCC类的对象WITHCC(注意内嵌的对象WOCC的初始化方法)。

    在main()函数中,语句:

    composite c2 = c;

    通过对象C初始化对象c2,缺省的复制构造函数被调用。

    最好的方法是创建自己的复制构造函数而不要指望编译器创建,这样就能保证程序在我们自己的控制之下。

    展开全文
  • 复制构造函数介绍浅拷贝拷贝 介绍 复制构造函数用于将一个对象复制到新对象中。它用于初始化过程中(包括按值传递函数),而不是常规的赋值过程中,类型如下: Class_name(const Class_name &); 它接受一个...

    复制构造函数

    介绍

    复制构造函数用于将一个对象复制到新对象中。它用于初始化过程中(包括按值传递函数),而不是常规的赋值过程中,类型如下:

    Class_name(const Class_name &);
    

    它接受一个指向类对象的常量引用作为参数。对于复制构造函数,需要知道两点:何时调用和有和功能。
    1.如何调用
    创建一个对象并将其初始化为同类现有对象时,复制构造函数都将被调用。有四种方式

    Person ob;
    Person ob1(ob);//1
    Person ob2=ob;//2
    Person ob3 = Person (ob);//2
    Person * ob4= new Person(ob);//3
    

    2.默认构造函数功能
    1.默认的复制构造函数逐个复制非静态成员(成员复制也称浅复制),复制的是成员的值。

    Person ob("Tom",12,99.9);
    Person ob1=ob;
    

    浅拷贝

    #include <iostream>
    #include<string.h>
    #include<stdlib.h>
    using namespace std;
    class Person
    {
    private:
        char *m_name;
        int m_num;
    public:
        Person()
        {
            m_name = NULL;
            m_num = 0;
            cout<<"无参构造"<<endl;
        }
        Person(char *name,int num)
        {
            //为m_name申请空间
            m_name = (char *)calloc(1,strlen(name)+1);
            if(m_name == NULL)
            {
                cout<<"构造失败"<<endl;
            }
            cout<<" 已经申请好空间"<<endl;
            strcpy(m_name,name);
            m_num = num;
            cout<<"有参构造"<<endl;
        }
        ~Person()
        {
            if(m_name != NULL)
            {
                cout<<"空间已被释放"<<endl;
                free(m_name);
                m_name = NULL;
            }
            cout<<"析构函数"<<endl;
        }
    
        void showPerson(void)
        {
            cout<<"m_name = "<<m_name<<", m_num = "<<m_num<<endl;
        }
    };
    
    void test01()
    {
        Person ob("lucy",100);
        ob.showPerson();
        // 浅拷贝
        Person ob1= ob;//调用系统的默认拷贝构造(单纯的值拷贝)
    }
    int main(int argc, char *argv[])
    {
        test01();
        return 0;
    }
    

    在这里插入图片描述

    深拷贝

    1.在上面的浅拷贝中在运行中ob会调用析构函数释放空间,浅拷贝ob1也会调用析构函数空间,导致释放两次调用两次析构函数,释放两次空间,出现多次释放同一块堆区空间。
    2.使用new初始化的指针成员,应当定义一个复制构造函数,以复制指向的数据,而不是指针,这被称为深拷贝。
    所有使用深拷贝解决浅拷贝的问题:

    #include <iostream>
    #include<string.h>
    #include<stdlib.h>
    using namespace std;
    class Person
    {
    private:
        char *m_name;
        int m_num;
    public:
        Person()
        {
            m_name = NULL;
            m_num = 0;
            cout<<"无参构造"<<endl;
        }
        Person(char *name,int num)
        {
            //为m_name申请空间
            m_name = (char *)calloc(1,strlen(name)+1);
            if(m_name == NULL)
            {
                cout<<"构造失败"<<endl;
            }
            cout<<" 已经申请好空间"<<endl;
            strcpy(m_name,name);
            m_num = num;
            cout<<"有参构造"<<endl;
        }
    
        Person(const Person &ob)//ob==>ob
        {
            cout<<"拷贝构造函数"<<endl;
            m_name = (char *)calloc(1, strlen(ob.m_name)+1);
            cout<<"空间已被申请"<<endl;
            strcpy(m_name, ob.m_name);
    
            m_num = ob.m_num;
        }
    
        ~Person()
        {
            if(m_name != NULL)
            {
                cout<<"空间已被释放"<<endl;
                free(m_name);
                m_name = NULL;
            }
            cout<<"析构函数"<<endl;
        }
    
        void showPerson(void)
        {
            cout<<"m_name = "<<m_name<<", m_num = "<<m_num<<endl;
        }
    };
    
    void test01()
    {
        Person ob("lucy",100);
        ob.showPerson();
    
       
        //通过自定义 拷贝构造函数 完成深拷贝动作
        Person ob1 = ob;
    }
    int main(int argc, char *argv[])
    {
        test01();
        return 0;
    }
    

    在这里插入图片描述
    注:如果类中的成员 指向了堆区空间 一定要记得在析构函数中 释放该空间
    如果用户 不实现 拷贝构造 系统就会提供默认拷贝构造
    而默认拷贝构造 只是单纯的赋值 容易造成浅拷贝问题
    用户记得 要实现:无参构造(初始化数据)、有参构造(赋参数)、拷贝构造(深拷贝) 、析构函数(释放空间)

    展开全文
  • 移动构造函数与拷贝构造函数

    千次阅读 2021-03-07 11:15:14
    一、移动构造函数: 定义: 所谓移动语义,指的就是以移动而非深拷贝的方式初始化含有指针成员的类对象。简单的理解,移动语义指的就是将其他对象(通常是临时对象)拥有的内存资源“移为已用”。 优点: 提高执行...
  • 构造函数 是为了让我们自己去规定 , 我们定义对象的初始化。 #include <iostream> using std::cin; using std::cout; using std::endl; class Clock{ public: void setTime(int newS = 0, int newM = 0, ...
  • Java中的拷贝构造函数

    2021-02-12 16:18:03
    1.介绍Java 中的拷贝构造方法是一种使用该类的一个对象构造另外一个对象的构造方法。...2.如何创造拷贝构造方法要创建拷贝构造方法,首先需要声明带有本类相同类型的参数构造函数:public class Employee ...
  • 1. 构造函数的重载 2. 缺省构造函数 只要对象被创建,就会调用构造函数 #include <iostream> using namespace std; class A { public: A(void){ cout << "无参构造函数" << endl; m_i = 0...
  • 首先讲讲拷贝构造函数拷贝构造函数是先将传入的参数对象进行一次深拷贝,再传给新对象。这就会有一次拷贝对象的开销,并且进行了深拷贝,就需要给对象分配地址空间。 而移动构造函数就是为了解决这个拷贝开销而...
  • 一、复制构造函数定义 复制构造函数是一种特殊的构造函数,其形参为本类的对象引用。作用是用一个已知的对象去初始化同类型的新对象。 class 类名 { public: 类型(形参);//构造函数 类名(const 类名 &...
  • 其实自己对这两个区别是一直不怎么弄懂的,而且也曾经问过别人是怎么一个区别,不过人家说...记得当初我是这么问别人的:有了拷贝构造函数,就可以b =a;也没有错了,那么还要重载赋值运算符干嘛?两个有什么区别吗?...
  • C++中一般创建对象,拷贝或赋值的方式有构造函数,...(构造函数的命名必须类名完全相同)首先说一下一个C++的空类,编译器会加入哪些默认的成员函数默认构造函数和拷贝构造函数析构函数赋值函数(赋值运算符)取值...
  • 拷贝构造函数详解

    千次阅读 2021-02-02 15:04:44
    拷贝构造函数是构造函数的一种, 也称复制构造函数, 只有一个参数, 参数类型是该类的引用. [拷贝构造函数的参数可以是 const 引用,也可以是非 const 引用。 一般使用前者,这样既能以常量对象(初始化后值不能...
  • #include <iostream> #include <string> using namespace std; class CTest { public: CTest(int iData, string strData) { m_iData = iData; m_strData = strData;... m_iDat...
  • 写一个拷贝构造函数通常,为了初始化类的实例变量的值(一种方式),我们创建一个参数化的构造函数,接受所有实例变量的值,并使用给定的值对其进行初始化。intname;intage;publicStudent(String...
  • 拷贝构造函数与移动构造函数拷贝构造函数与移动构造函数的区别参考 拷贝构造函数与移动构造函数的区别 拷贝构造函数的形参是一个左值引用 拷贝构造函数完成的是整个对象或变量的拷贝 … … 移动构造函数的形参是一个...
  • 我正在通过复制构造函数,我已经通过流程其他的堆栈链接.但我不清楚以下几点.>为什么我们需要一个复制构造函数>我们什么时候需要一个复制构造函数我的意思是我们需要使用复制构造函数的确切情况或场景.有人...
  • //用对象A初始化对象B,拷贝构造函数被调用. } 2 如果函数的形参是类的对象,调用函数时,进行形参实参结合时 void f(point p) { } main() { point A(1,2); f(A);//函数的形参为类的对象时,当调用函数时,拷贝构造...
  • 游戏开发之拷贝构造函数,即复制构造函数(explicit关键字及拷贝构造函数的调用时机)(C++基础) 拷贝构造函数是一个特殊的构造函数,是用一个类对象赋值给另外一个类对象时调用。 拷贝构造函数如果没有重写,...
  • 构造函数 构造函数的两阶段执行 1、初始化阶段; 所有类型的成员都会在初始化阶段被初始化,即使该成员没有出现在构造函数的初始化列表中。 (1)、初始化列表中显示初始化的成员,按照列表中圆括号内的值初始化。 (2)...
  • 编译器对连续的构造函数和拷贝构造函数的优化

    多人点赞 热门讨论 2021-07-20 22:04:38
    传值 : 在调用f1(a1)函数时,会首先进行压参数,即用 a1 拷贝构造 aa,会调用拷贝构造函数,f1函数调用结束后,aa对象销毁,执行析构函数,接着main函数调用结束,a1对象销毁,执行析构函数 传引用 : 在调用f1(a1)...
  • 这里是我注意到的问题: 复制构造函数不适用于泛型。 这里有一些伪代码,无法编译。 public class MyClass{ .. public void copyData(T data){ T copy=new T(data);//This isn't going to work. } .. } 示例1:在...
  • 构造函数就是类名一样,而且是没有返回值的函数。如下所示: class demo_class { public: demo_class();//构造函数 如果不指定属性,则默认为私有的 }; 如果类里面的构造函数demo_class是私有的,那样就...
  • 类的兼容性是指在需要基类对象的任何地方都可以使用派生类来替代,通过继承,派生类得到了除了基类构造函数复制函数中的所有成员。这样公有派生类实际具备了基类所有的功能,凡是基类所能解决的问题,公有派生类都...
  • 但是,与C ++不同的是,如果您不写自己的Java,则不会创建默认的拷贝构造函数。以下是一个示例Java程序,显示了复制构造函数的简单使用。// filename: Main.javaclass Complex {private double re, im;// A normal p...
  • clone方法实现对象的复制在Java API中,如果被克隆的对象成员变量有对象变量,则对象变量也需要实现Cloneable接口,并重新给新的父类赋值,例如:1.创建一个对象,其存在对象类型的成员变量childCloneclass ParentsCl...
  • 复制构造函数 是一种特殊的构造函数,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。 复制构造函数通常用于: 通过使用另一个同类型的对象来初始化新创建的对象。 复制对象把它作为参数...
  • I have a class which is publicly inherited from QWidget:class MyWidget : public QWidget{Q_OBJECTpublic:MyWidget(const MyWidget& other):obj1(other.obj1),obj2(other.obj2)private:some_class obj1;...
  • 1.构造函数 1.1 定义 构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都有 一个合适的初始值,并且在对象的生命周期内只调用一次。 1.2 特性 构造函数是用来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,455
精华内容 42,182
关键字:

复制构造函数和拷贝构造函数区别