精华内容
下载资源
问答
  • 一种形式:派生类拷贝构造函数名(对象p的引用):基类构造函数名(参数列表) 如:student::student(student&p):stud(p.num,p.name,p.sex) //注意,参数形式,是对象的引用,我们知道引用是C++特有的,这又...

    在派生类中如何写拷贝构造函数

    一种形式:派生类拷贝构造函数名(对象p的引用):基类构造函数名(参数列表)

    如:student::student(student&p):stud(p.num,p.name,p.sex)
    //注意,参数形式,是对象的引用,我们知道引用是C++特有的,这又是一个引用的用法 呵呵

    一种形式:派生类拷贝构造函数名(对象p的引用):基类拷贝构造函数名(p)

    如:student::student(student &p):stud( p)

    注意:在调用基类的构造函数时或拷贝构造函数时,参数一定要干净,啥都不带,就是个参数名,如是数组就写数组名,如是对象,就写对象名!

    组合类构造函数一般形式

    #include <iostream>
    #include<cmath>
    using namespace std;
    class Point
    {
    public:
     

    Point(int xx=0,int yy=0){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<<”Point拷贝构造函数被调用”<<endl;}
    //拷贝构造函数或者可以使用下面的表示方法

    //类的组合
     class Line
     {
       public:
        Line(Pointxp1,Point xp2);
        Line(Line&);
        doubleGetLen(){return len;}
       private:
        Pointp1,p2;
        doublelen;
     };

     //组合类的构造函数

     Line::Line(Point xp1,Pointxp2):p1(xp1),p2(xp2)  //构造函数
     {
     
     cout<<”Line构造函数被调用”<<endl;
     double x=double(p1.GetX()-p2.GetX());
     double y=double(p1.GetY()-p2.GetY());
    len=sqrt(x*x+y*y);
     }
     //组合类的拷贝构造函数
     
     Line::Line(Line&L):p1(L.p1),p2(L.p2)//拷贝构造函数
     {
     cout<<”Line拷贝构造函数被调用”<<endl;
     len=L.len;
     }
     //主函数
     int main()
     {
     Point myp1(1,1),myp2(4,5);
     Line line(myp1,myp2);
     Line line2(line);
     cout<<”The lengthof the line is:”;
     cout<<line.GetLen()<<endl;
     cout<<”The lengthof the line2 is:”;
     cout<<line2.GetLen()<<endl;
     }

    //注意常数据成员只能通过初始化列表来获得初值,如

    #include <iostream>
    using namespace std;
    class A
    {
    public:
        A(inti);
     void print();
        const int&r;
    private:
        const inta;
        static constint b;//静态常数据成员
    };
    const int A::b=10;//静态常数据成员在类外说明和初始化
    A::A(int i):a(i),r(a)  //常数据成员只能通过初始化列表来获得初始值
       {
       }
    void A::print()
    {
    cout<<a<<”:”<<b<<”:”<<r<<endl;
    }
    int main()
    {
    A a1(100),a2(0);
    a1.print();
    a2.print();
    }

    转载于:https://www.cnblogs.com/luscinia/p/4177905.html

    展开全文
  • 在进入派生类(derived)的拷贝构造函数之前,就已经调用了基类(based)的构造函数, 无论你有没有显示的调用。 一般派生类是这种形式: derived(const derived & d):based(d) {} 为什么使用下列形式不行 ...
  • 【注意】对派生类进行拷贝构造时,如果想让基类的成员也同时拷贝,就一定要在派生类拷贝构造函数初始化列表中显示调用基类拷贝构造函数(当然在函数体内将基类部分的值拷贝也是可以的,只不过它是先用默认构造函数...

    学习资料

    派生类的赋值运算符/赋值构造函数也必须处理它的基类成员的赋值

    • C++ 基类构造函数带参数的继承方式及派生类的初始化

     

    定义拷贝构造函数

    【注意】对派生类进行拷贝构造时,如果想让基类的成员也同时拷贝,就一定要在派生类拷贝构造函数初始化列表中显示调用基类拷贝构造函数(当然在函数体内将基类部分的值拷贝也是可以的,只不过它是先用默认构造函数初始化后再修改的基类成员变量的值,效率比较低),否则它会调用基类的默认构造函数,而不会对基类的成员变量拷贝值,这样生成的对象,它的派生类部分和被拷贝的对象派生类部分一样,而基类部分则是默认构造函数的初始化结果。

    代码例子1:

     1 #include <iostream>
     2 using namespace std;
     3 
     4 class A
     5 {
     6 public:
     7     A() { cout << "A default constructor" << endl; }
     8     A(A&) { cout << "A copy constructor" << endl; }
     9 };
    10 class B : public A
    11 {
    12 public:
    13     B() { cout << "A default constructor" << endl; }
    14     B(B &b) { cout << "B copy constructor" << endl; }
    15 };
    16 
    17 int main()
    18 {
    19     B b;
    20     B c = b;
    21     return 0;
    22 }

    输出结果:

     

     

    代码例子2:

     1 #include <iostream>
     2 using namespace std;
     3 
     4 class A
     5 {
     6 public:
     7     A() { cout << "A default constructor" << endl; }
     8     A(A&) { cout << "A copy constructor" << endl; }
     9 };
    10 class B : public A
    11 {
    12 public:
    13     B() { cout << "A default constructor" << endl; }
    14     B(B &b) : A(b) { cout << "B copy constructor" << endl; }
    15 };
    16 
    17 int main()
    18 {
    19     B b;
    20     B c = b;
    21     return 0;
    22 }

    输出结果:

     

     

    C++ 基类构造函数带参数的继承方式及派生类的初始化

    在定义类的时候,会遇到基类的构造函数带参数,而子类子类构造函数不带参数,这时候如果以代码 a 的方式建立派生类则会出错。

     1 class A
     2 {
     3     public:
     4         A(int x, int y): i(x), j(y) {}
     5     private:
     6         int i, j;
     7 };
     8 
     9 class B : public A
    10 {
    11     public:
    12         B() { cout << "init B" << endl; }
    13 };

    在建立B类对象时,编译出错: 
     C:\Documents and Settings\admin\桌面\Text1.cpp(104) : error C2512: ‘A’ : no appropriate default constructor available 

     

    解决这个问题应该在A的构造函数中显式调用基类的带参构造函数。因为在基类中定义了带参构造函数,编译器不会提供默认构造函数。(或者可以在基类中增加一个不带参数的构造函数)这个问题将解决。 
    代码 b 采用的是调用基类带参构造函数的方式:

    代码 b:

     1 class A
     2 {
     3     public:
     4         A(int x, int y): i(x), j(y) {}
     5     private:
     6         int i, j;
     7 };
     8 
     9 class B : public A
    10 {
    11     public:
    12         B() A(10,20) { cout << "init B" << endl; }
    13 };

     

    通过在基类中增加一个不带参数的构造函数: 
    代码 c:

     1 class A
     2 {
     3     public:
     4         A(int x, int y): i(x), j(y) {}
     5         A();   //不带参数的构造函数
     6     private:
     7         int i, j;
     8 };
     9 
    10 class B:public A
    11 {
    12     public:
    13         B(): A(10,20) { cout << "init B" << endl; }
    14 };

     

    定义派生类赋值运算符

    与拷贝和移动构造函数一样,派生类的赋值运算符也必须为其基类部分赋值。

    1 // Base::operator=(const Base&) 不会被自动调用
    2 D& D::operator=(const D &rhs)
    3 {
    4     Base::operator=(rhs);  //为基类部分赋值
    5     //按照过去的方式为派生类的成员赋值
    6     return *this;
    7 }

     举例说明:

     1 class base 
     2 {
     3 public:
     4   base(int initialvalue = 0): x(initialvalue) {}
     5 
     6 private:
     7   int x;
     8 };
     9 
    10 class derived : public base 
    11 {
    12 public:
    13   derived(int initialvalue): base(initialvalue), y(initialvalue) {}
    14   derived& operator=(const derived& rhs);
    15 
    16 private:
    17   int y;
    18 };
    19 
    20 逻辑上说,derived的赋值运算符应该象这样:
    21 derived& derived::operator = (const derived& rhs) // 错误的赋值运算符
    22 {                                                 // 请注意d1的base部分没有被赋值操作改变。
    23   if (this == &rhs) 
    24     return *this;  
    25   y = rhs.y;                                                          
    26   return *this;                      
    27 }
    28 
    29 不幸的是,它是错误的,因为derived对象的base部分的数据成员x在赋值运算符中未受影响。例如,考虑下面的代码段:
    30 
    31 void assignmenttester()
    32 {
    33   derived d1(0);      // d1.x = 0, d1.y = 0
    34   derived d2(1);      // d2.x = 1, d2.y = 1
    35 
    36   d1 = d2;            // d1.x = 0, d1.y = 1
    37 }
    38 
    39 
    40 derived& derived::operator = (const derived& rhs) // 正确的赋值运算符
    41 {
    42   if (this == &rhs) 
    43     return *this;
    44 
    45   base::operator = (rhs);    // 调用this->base::operator=
    46   y = rhs.y;
    47 
    48   return *this;
    49 }

     

    转载于:https://www.cnblogs.com/sunbines/p/9215310.html

    展开全文
  • 如果派生类定义了自己的拷贝构造函数,该拷贝构造函数一般应显式的使用基类的拷贝构造函数初始化对象的基类部分 class Base { /* .... */} class Derived : public Base { public:  // Base::Base的...

    如果派生类定义了自己的拷贝构造函数,该拷贝构造函数一般应显式的使用基类的拷贝构造函数初始化对象的基类部分

    class Base { /* .... */}
    class Derived : public Base {
    public:
        // Base::Base的Base(const Base &)拷贝构造函数不会自动调用
        // 初始化函数Base(d)将派生类对象d转化为它的基类部分的引用,并调用基类拷贝构造函数
        Derived (const Derived &d) : Base(d) {
        }
    }


    转载于:https://my.oschina.net/zhaomengit/blog/322670

    展开全文
  • //定义:Birthday class Birthday { public: Birthday(int y) { year = y; } private: int year; }; //定义:Men class Men { public: Men(i
    //定义类:Birthday
    class Birthday
    {
      public:
               Birthday(int y)
              {
                      year = y;
               }
      private:
               int year;
    };
    
    //定义类:Men
    class Men
    {
    public:
           Men(int y):bir(y)
           {
           }
    private:
           //声明类对象成员
           Birthday bir;      
    };
    
    //定义类:Teacher
    class Teacher:public Men
    {
         //定义拷贝构造函数
         Teacher(const Teacher &t):Men(t.bir.year)
       {
          }
    };
    大概就这样。想做Teacher的拷贝构造函数,会出的错误就是 t 引用的对象没有对 year 的使用权限。百度过,没有找到答案。想过把 Birthday 做成 Men 的基类,但是生日派生出人,这好像有点扭曲了。也想过把那个拷贝构造函数声明为 Birthday  的友元,可是也不对。我该怎么办?
    展开全文
  • 构造函数 ,是一种特殊的方法 。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new...特别的一个可以有多个构造函数 ,可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。
  • C++:派生类的默认构造函数和拷贝构造函数调用基类构造函数的机制(含程序验证) 1、如果基类定义了不带参数的默认构造函数,则编译器为派生类自动生成的默认构造函数会调用基类的默认构造函数。 2、如果基类定义...
  • C++派生类构造函数

    千次阅读 2017-08-14 22:00:44
    派生类构造函数 默认情况 基类的构造函数不被继承; 派生类需要定义自己的构造函数。 C++11规定 可用using语句继承基类构造函数。 但是只能初始化从基类继承的成员。 派生类新增成员可以通过类内初始值进行...
  • 如果要派生类构造函数想调用重载的基类构造函数那么就必须 D(): B(参数){} 拷贝构造函数 关于继承可以看我的这一篇添加链接描述 #include <iostream> #include <string> using namespace std; class B...
  • 复制成员和构造函数式 一、派生类构造函数
  • 派生类构造函数

    2014-07-19 16:48:18
    1.派生类的概念 以面向对象的程序设计的观点来看,继承表达的是对象类之间的相互关系。这种关系使得某类对象可以继承另外一类对象的特征和能力。如果一类对象继承了另一类对象的特征和能力,这个类就叫做所继承类的...
  • 我们前面说过 ,基类的构造函数是不能继承的,在声明派生类时,派生类并没有把基类的构造函数给继承过来,所以基类的初始化工作也要由派生类构造函数承担。所以在设计派生类构造函数时,不仅要考虑派生类所增加...
  • A:继承与派生过程中,基类的构造函数不能被继承,派生类中需要声明自己的构造函数。 B:声明构造函数时,只需要对本类中新增成员进行初始化。至于基类继承过来的成员,应该调用基类的构造函数来完成 C:需要强调的是...
  • 定义派生类复制构造函数

    千次阅读 2018-07-09 13:52:18
    如果派生类显示定义自己的复制构造函数或赋值操作符,则该定义将完全覆盖默认定义。被继承类的复制构造函数和赋值操作符负责对基类成分以及类自己的成员进行复制或赋值。 如果派生类定义了自己的复制构造函数,该...
  • 拷贝构造,也是一种构造函数,也是没有被继承下来的,子类中也需要进行相应的调整 规则: 子类 当子类不自实现时,默认调用父类的拷贝构造 若自实现,不做特殊处理,此时只会调用父类的构造器 特殊处理:显示调用父类的...
  • 刚刚弄了一个关于派生类的实验,里面涉及到了派生类拷贝构造函数,这时才发现自己在这个知识点上还很模糊。在CSDN上面看了下相关的一篇文章后,稍微有了点感觉。现总以一个例子总结如下:情况(1). 派生类的copy ...
  • 因此,派生类构造函数必须通过调用基类的构造函数初始化基类成员,不能够在派生类初始化列表直接初始化基类的成员,“越级初始化”。派生类构造函数的一般格式为: 派生类名(形参表):基类名1(形参表1),...
  • C++派生类构造函数和复制控制

    千次阅读 2012-11-19 21:11:54
    派生类构造函数和复制控制成员不能继承,每个类定义自己的构造函数和复制控制成员,像任何类一样,如果类没有定义自己的构造函数和复制控制成员,编译器自动合成。 1.构造函数 派生类构造函数先要初始化基类的...
  • 一个经常发生的和继承有关的类似问题是在实现派生类拷贝构造函数时。看看下面这个构造函数:www.huaqiangu6.comclassbase{public:base(intinitialvalue=0):x(initialvalue){}base(constbase&rhs):x(rhs.x){}...
  • //{// 因此如需模板基类的拷贝构造函数,可在派生类中不定义拷贝构造函数, //}// 或者亦可在派生类中应用初始化参数列表显式调用模板基类的拷贝构造函数 ~B()// 析构函数将调用模板基类的析构函数 { } //B &...
  • 而不是按初始化列表的次序调用3调用派生类子对象的构造函数,按子对象的次序调用,不按初始化列表的次序调用,4执行派生类的构造数 5virtual是虚基类的关键字,使用虚基类的进行派生类声明时内存中积累成员只会存在...
  • 今天主要讲解虚基类及其派生类构造函数。 1.虚基类的概念及用法 上 一讲中说过,如果派生类的全部或者部分基类有共同的基类,那么派生类的这些直接基类从上一级基类继承的成员都具有相同的名称,定义了派生类的...
  • 注意:如果中没有说明拷贝构造函数,则系统自动生成一个缺省复制构造函数,作为该的公有成员 下面有一个String的例子,说明拷贝构造函数的使用: #ifndef _STRING_H_ #define _STRING_H_ class String { p
  • 对 c++成员函数中的构造函数 拷贝构造函数 析构函数 赋值运算符重载的一些特点以及函数调用顺序,并附上例子,希望对大家有帮助,有错误大家可以指出来。
  • 1派生类构造函数 派生类构造函数定义的一般形式为: 派生类名::派生类名(基类所需形参,本类成员所需形参):基类1(基类1 参数表),基类2(基类2 参数表),···,基类n(基类n 参数表),对象成员1...
  • 派生类中“显示定义了拷贝构造函数和赋值操作符时” 如果派生类中的拷贝和赋值构造函数中没有“显示指定基类的拷贝和赋值构造函数”,即:派生类只是把自己的成员进行了赋值 这时需要手动调用基类的拷贝构造...
  • 如何对派生类拷贝构造函数以及赋值运算符的重载进行编写 下面是一个实例,或许大家看了之后就明白了 #include #include using namespace std; class Traveler { string str; ...
  • 1. 当派生类定义了拷贝或移动构造函数,必须显式地调用基类的拷贝或移动构造函数,否则会调用基类的默认构造函数 #include <iostream> class Base { public: Base() { std::cout << "Base default ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,302
精华内容 14,120
关键字:

派生类拷贝构造函数