body, table{font-family: 微软雅黑; font-size: 10pt}
table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;}
th{border: 1px solid gray; padding: 4px; background-color: #DDD;}
td{border: 1px solid gray; padding: 4px;}
tr:nth-child(2n){background-color: #f8f8f8;}

继承:
         面向对象程序设计的一个重要特点就是可以在既有类的基础上定义新的类，而不用将既有类的内容重新书写一遍，这称为“继承”（inheritance），既有类称为“基类”或“父类”，在它的基础上建立的类称为“派生类”或“子类”          
qt , com组件     
什么是继承:
          面向对象的程序设计(OOP)而言，继承的引入使程序员可以按现实世界、按自然的方式去思考和解决问题，组织信息，提高了效率，其次，可以复用基类的代码，并可以在派生类中增加新代码或者覆盖基类的成员函数，为基类成员函数赋予新的意义，实现最大限度的代码复用。
1、继承的定义形式一般如下：
       class 派生类 : 派生方式 基类 {…};        //public, protected, private
2、派生类生成过程包含3个步骤：
     ——吸收基类的成员
     ——改造基类的成员
     ——添加自己新的成员

继承的层次性：

       任何一个类都可以派生出新类，派生类还可以再派生出新的类，因此，基类和派生类是相对而言的。一个基类可以是另一个基类的派生类，这样便构建了层次性的类结构，如所示，类B是A的派生类，同时又派生了新类C，B又可以看作是C的基类。
继承的局限：

1、不论何种继承方式，下面这些基类的特征是不能从基类继承下来的：
——构造函数
——析构函数
——用户重载的new 、delete运算符
       operator new /operator delete
——用户重载的=运算符
——友元关系
派生方式：
       派生有public、protected、private三种方式，不同的派生方式下，派生类对基类成员的访问权限以及外部对基类成员的访问权限有所不同。
1、public派生与private派生

C++中，利用基类派生其子类（派生类）的基本格式为：
class 派生类名：派生方式 基类名
{
private:
        新增私有成员列表;
public:
        新增公开成员列表;
};
2、派生类访问权限
● 通过继承，派生类自动得到了除基类私有成员以外的其它所有数据成员和成员函数，在派生类中可以直接访问。
● private成员是私有成员，只能被本类的成员函数所访问，派生类和类外都不能访问。
● public成员是公有成员，在本类、派生类和外部都可访问
● protected成员是保护成员，只能在本类和派生类中访问。是一种区分血缘关系内外有别的成员。
● 派生类的访问权限规则如下：
     1．不管是什么继承方式，子类中都不能访问父类的私有成员。
     2．子类内部除了基类的私有成员不可以访问外，其他的都可以访问。
     3．除了公有继承基类中的公有成员，子类对象可以访问外，其他的,子类对象一律不能访问 。

#include <iostream>
using namespace std;
class Point
{
        public:
                Point(int ix=0,int iy=0):_ix(ix),_iy(iy)
                {        cout<<"Point(int,int)"<<endl;        }
                int getx()const
                {       return _ix;       }
                int gety()const
                {        return _iy;      }
                void display()
                {        cout<<"("<<_ix<<","<<_iy<<")"<<endl;        }
        private:
                int _ix;
                int _iy;
};
class Point3D:public Point
{
        public:
                Point3D(int ix,int iy,int iz):Point(ix,iy),_iz(iz)
                {        cout<<"Point3D(int,int,int)"<<endl;        }
                void display() //隐藏了基类中的同名函数
                {
                        cout<<"("<<getx()<<","<<gety()<<","<<_iz<<")"<<endl;   //不能直接访问基类的私有成员
                }
        private:
                int _iz;
};
int main()
{
        Point3D point3d(1,2,3);
        point3d.display();
        return 0;
}

#include <iostream>
using namespace std;
class Point
{
        public:
                Point(int ix=0,int iy=0):_ix(ix),_iy(iy)
                {        cout<<"Point(int,int)"<<endl;        }
                int getx()const
                {        return _ix;        }
        protected:
                int gety()const
                {        return _iy;        }
        public:
                void display()
                {        cout<<"("<<_ix<<","<<_iy<<")"<<endl;        }
        private:
                int _ix;
                int _iy;
};
class Point3D:private Point
{
        public:
                Point3D(int ix,int iy,int iz):Point(ix,iy),_iz(iz)
                {        cout<<"Point3D(int,int,int)"<<endl;        }
                void display() //隐藏了基类中的同名函数
                {               
                        cout<<"("<<getx()<<","<<gety()<<","<<_iz<<")"<<endl;   //不能直接访问基类的私有成员
                }
        private:
                int _iz;
};
int main()
{
        Point point(1,2);
        //point.gety();   //protected修饰的成员不能通过对象访问
        point.display();
        Point3D point3d(1,2,3);
        point3d.display();
        return 0;
}
3、多基派生
     派生类只有一个基类时，称为单基派生，在实际运用中，我们经常需要派生类同时具有多个基类，这种方法称为多基派生或多重继承，下图所示是双基继承的示意，在实际应用中，还允许使用三基甚至是更多基继承。
4、多基派生的声明和定义
     在C++中，声明和定义具有两个以上基类的派生类与声明单基派生类的形式类似，只需将要继承的多个基类用逗号分开即可，如
class 派生类名:继承方式1 基类名1,继承方式2 基类名2,…,继承方式n 基类名n
{
private:
        新增私有成员列表;
public:
        新增公开成员列表;
};
例如，从A类和B类派生出C类的方式如下：
class C : public A, public B
{
        //……
};

5、多基派生的二义性问题

     在派生类中对基类成员的访问应当具有唯一性，但在多基继承时，如果多个基类中存在同名成员的情况，造成编译器无从判断具体要访问的哪个基类中的成员，则称为对基类成员访问的二义性问题
6、多基派生二义性问题的解决方案
    ●作用域限定符
    ●虚基类
7、共同基类(虚基类)
     多基派生中，如果在多条继承路径上有一个共同的基类，如图10.4所示，不难看出，在D类对象中，会有来自两条不同路径的共同基类（类A）的双重拷贝。
8、共同基类的二义性

     共同基类和多基派生的共同作用，使得在派生类中会出现多个共同基类的拷贝，这很容易带来二义性问题
如下图所示，D类通过B类和C类各继承了一次A类的函数SetX()和Print()，从而产生了二份拷贝，进而导致了二义性
9、共同基类二义性问题的解决方案
     使用关键字virtual将共同基类A声明为虚基类，可有效解决上述问题。在定义由共同基类直接派生的类（类B和类C）时，使用下列格式定义：
class 派生类名 : virtual 派生方式 基类名
{
        //类定义
};
虚基派生和多基派生带来的二义性有些细微的差别：
1、多基派生的二义性主要是成员名的二义性，通过加作用域限定符来解决。
2、虚基派生的二义性则是共同基类成员的多重拷贝带来的存储二义性，使用virtual派生来解决

另外，二义性的检查是在访问权限检查之前进行的，因此，成员的访问权限是不能消除二义性的

//多基派生产生的二义性
#include <iostream>
using namespace std;
class A
{
        public:
                void print()
                {   cout<<"A::print()"<<endl;  }
};
class B
{
        public:
                void print()
                {   cout<<"B::print()"<<endl;   }
};
class C:public B,public A
{
        public:
                void display()
                {
                        cout<<"C::display()"<<endl;
                        A::print();  //解决名字冲突二义性
                        B::print();
                }
               void print()
               {
                       cout<<"C::print()"<<endl;
               }
};
int main()
{
        C c;
        c.display();  
        c.A::print();  // 调用A类额的print  
        c.print()  // 默认调用类C里面的 
        return 0;
}
//
C::display()
A::print()
B::print()
A::print()
C::print()
//虚基派生产生的二义性
#include <iostream>
using namespace std;
class A
{
        public:
                A(int x=0):_x(x)
                {   cout<<"A(int)"<<endl;  }
                void setx(int x)
                {   _x=x;   }
                void print()
                {   cout<<"A::_x="<<_x<<endl;   }
        protected:
                int _x;
};
//存储二义性问题，采用虚继承的方式解决
class B:virtual public A {};
class C:virtual public A {};
class D:public B,public C{};
int main()
{
        D d;
        cout<<"sizeof(C)="<<sizeof(C)<<endl; 
        cout<<"sizeof(B)="<<sizeof(B)<<endl;
        cout<<"sizeof(D)="<<sizeof(d)<<endl;   //不加virtual结果是 4、4、8
        d.setx(5);    //不加virtual这里产生二义性，编译不通过
        d.print();     //virtual派生，在D中只有一个版本，不会产生二义性
        return 0;
}

单基派生类的构造函数和析构函数

      ★ 派生时，构造函数和析构函数是不能继承的，为了对基类成员进行初始化，必须对派生类重新定义构造函数和析构函数，并在构造函数的初始化列表中调用基类的构造函数。
      ★由于派生类对象通过继承而包含了基类数据成员，因此，创建派生类对象时，系统首先通过派生类的构造函数来调用基类的构造函数，完成基类成员的初始化，而后对派生类中新增的成员进行初始化。
      ——如果派生类有显式定义构造函数，而基类没有，则创建派生类的对象时，派生类相应的构造函数会被自动调用，此时都自动调用了基类缺省的无参构造函数。
      ——如果派生类没有显式定义构造函数而基类有，则基类必须拥有默认构造函数。
      ★如果派生类有构造函数，基类有默认构造函数，则创建派生类的对象时，基类的默认构造函数会自动调用，如果你想调用基类的有参构造函数，必须要在派生类构造函数的初始化列表中显示调用基类的有参构造函数。 
      ★如果派生类和基类都有构造函数，但基类没有默认的无参构造函数，即基类的构造函数均带有参数，则派生类的每一个构造函数必须在其初始化列表中显示的去调用基类的某个带参的构造函数。如果派生类的初始化列表中没有显示调用则会出错，因为基类中没有默认的构造函数。

1、单基派生类的构造函数

      ★派生类构造函数的一般格式为：
派生类名(总参数表): 基类构造函数(参数表)
{
        //函数体
};
      ★必须将基类的构造函数放在派生类的初始化表达式中，以调用基类构造函数完成基类数据成员的初始化，派生类构造函数实现的功能，或者说调用顺序为：
1、完成对象所占整块内存的开辟，由系统在调用构造函数时自动完成。
2、调用基类的构造函数完成基类成员的初始化。
3、若派生类中含对象成员、const成员或引用成员，则必须在初始化表中完成其初始化。
4、派生类构造函数体执行。

#include <iostream>
using namespace std;
//当派生类显示定义了构造函数，而基类没有显示定义构造函数，
//如果创建派生类对象，此时自动调用基类的默认构造函数
class Base
{
        public:
                Base()
                {  cout<<"Base()"<<endl;  }
        private:
                int _ix;
};
class Derived:public Base
{
        public:
                Derived()
                {  cout<<"Derived()"<<endl;  }
                Derived(int ix)
                {  cout<<"Derived(int)"<<endl;  }
};
int main()
{
        Derived d1(5);
        return 0;
}
#include <iostream>
using namespace std;
//当派生类没有显示提供任何构造函数，而基类显示提供了有参构造函数，那
//么在创建派生类对象时，要求基类必须显示的提供一个默认构造函数
class Base
{
        public:
                Base()
                {  cout<<"Base()"<<endl;  }
                Base(int x)
                {  cout<<"Base(int)"<<endl;  }
        private:
                int _x;
};
class Derived:public Base{};   //系统会提供默认的构造函数
int main()
{
        Derived d1;
        return 0;
}
#include <iostream>
using namespace std;
//当派生类和基类都显示定义了构造函数
//在创建派生类对象时，如果希望调用基类的有参
//构造函数，则需要在派生类构造函数的初始化列表
//之中显示的调用基类的构造函数
class Base
{
        public:
                Base()
                {  cout<<"Base()"<<endl;  }
                Base(int x):_x(x)
                {  cout<<"Base(int)"<<endl;  };
        private:
                int _x;
};
class Derived:public Base
{
        public:
                Derived():Base()   
 //显示调用Base的默认构造函数，可写可不写
                {  cout<<"Derived()"<<endl;  }
                Derived(int x):Base(x)     //显示调用基类的有参构造函数
                {  cout<<"Derived(int)"<<endl;  }
};
int main()
{
        Derived d1;
        Derived d2(1);
        return 0;
}
2、单基派生类的析构函数
      ★当对象被删除时，派生类的析构函数被执行。析构函数同样不能继承，因此，在执行派生类析构函数时，基类析构函数会被自动调用(与虚函数)。

★执行顺序是先执行派生类的析构函数，再执行基类的析构函数，这和执行构造函数时的顺序正好相反。

#include <iostream>
using namespace std;
class A
{
        public:
                A(int x=0):_x(x)
                {  cout<<"A::A(int)"<<endl;  }
                ~A()
                {  cout<<"A::~A()"<<endl;  }
        private:
                int _x;
};
class B
{
        public:
                B()
                {  cout<<"B::B()"<<endl;  }
                ~B()
                {  cout<<"B::~B()"<<endl;  }
};

class C:public A
{
        public:
                C(int x,int y):A(x),b(),_y(y)
                {  cout<<"C::C(int,int)"<<endl;  }
                ~C()
                {  cout<<"C::~C(int,int)"<<endl;  }
        private:
                int _y;
                B b;
};
int main()
{
        C c(1,2);
        return 0;
}

3、多基派生类的构造函数和析构函数

      ★多基派生时，派生类的构造函数格式如（假设有N个基类）：
派生类名(总参数表)：基类名1(参数表1)，基类名2(参数表2)，……，基类名N(参数表N)
{
        //函数体
}
      ★和单基派生类似，总参数表中包含了后面各个基类构造函数需要的参数。
      ★多基派生和单基派生构造函数完成的任务和执行顺序并没有本质不同，唯一一点区别在于首先要执行所有基类的构造函数，再执行派生类构造函数中初始化表达式的其他内容和构造函数体，各基类构造函数的执行顺序与其在初始化表中的顺序无关，而是由定义派生类时指定的基类顺序决定的。
      ★析构函数的执行顺序同样是与构造函数的执行顺序相反。


有继承关系的构造析构调用总结：

1、如果派生类还包括成员对象，则对成员对象的构造函数的调用，仍然在初始化列表中进行，此时，当创建派生类的一个对象时，首先基类构造函数被调用，成员对象所在类构造函数次之（在有多个成员对象的情况下，成员对象的调用顺序取决于他们在派生类中的申明顺序，与初始化列表中的顺序无关），最后执行派生类构造函数的函数体。
2、如果是多继承，在调用基类构造函数的时候，处于同一层次的各基类构造函数的调用顺序取决于定义派生类时所指定的继承基类顺序，与派生类构造函数中所定义的初始化列表顺序无关。
3、如果派生类有一个虚基类作为祖先类，那么在派生类构造函数的初始化列表中需要列出对虚基类构造函数的调用，如果未列出则表明调用的是虚基类的无参构造函数，不管初始化列表中次序如何，对虚基类构造函数的调用总是先于普通基类的构造函数。
4、继承机制下析构函数的调用顺序：
     ——先调用派生类的析构函数
     ——然后调用派生类中成员对象的析构函数
     ——再调用普通基类的析构函数
     ——最后调用虚基类的析构函数
派生类对基类成员的覆盖：

oversee  隐藏：父子类，函数名称相同，不带virtual关键字的函数
        
override 覆盖：父子类，函数的名称、返回值类型、参数的类型个数都相同有virtual关键字
        
overload 重载：同一个类，函数名称相同，参数不同（类型，顺序，个数）

     如果基类和派生类中存在同名的成员数据或者非虚的成员函数，那么派生类的成员数据和成员函数将隐藏基类的成员数据和成员函数，子类对象不能直接调用到基类的被隐藏的成员数据和成员函数，只能通过obj.CBase::Func(3);方式访问。而且与基类和派生类的访问属性无关（?）；与基类和派生类的函数间的参数和返回类型无关。
#include <iostream>
using namespace std;
class Base
{
        public:
                int func(int i)
                {  return _ix;  }
        protected:
                int _ix;
};
class Derived : public Base
{
        public:
                int func()
                {
                        _ix=9;   //访问派生类的_ix,发生了隐藏
                        Base::_ix = 22;  
//如果要访问基类的同名成员，必须使用基类的类名
                        return _ix;
                }
                void display()
                {
                        cout<<"Derived::_ix = "<<_ix<<endl;
                        cout<<"Base::_ix = "<<Base::_ix<<endl;
                }
        private:
                int _ix;
};
int main()
{
        Derived d;
        //cout<<d.func(3)<<endl;  
//和基类同名的函数，基类函数发生隐藏，要调用只能加上基类类名
        cout<<d.func()<<endl;
        cout<<d.Base::func(3)<<endl;       
        d.display();
        return 0;
}
//继承“是一个”
#include <iostream>
using namespace std;
class Eye
{
        public:
                void look()
                {   cout<<"Eye::lock()"<<endl;   }
};
class Nose
{
        public:
                void smell()
                {   cout<<"Nose::smell()"<<endl;   }
};
class Mouth
{
        public:
                void eat()
                {   cout<<"Mouth::eat()"<<endl;   }
};
class Ear
{
        public:
                void listen()
                {   cout<<"Ear::listen()"<<endl;   }
};
class Head:public Eye,public Nose,public Mouth,public Ear{};
int main()
{
        Head head;
        head.look();
        head.smell();
        head.listen();
        head.eat();
        return 0;
}
//组合 “有一个”
#include <iostream>
using namespace std;
class Eye
{
        public:
                void look()
                {   cout<<"Eye::lock()"<<endl;   }
};
class Nose
{
        public:
                void smell()
                {   cout<<"Nose::smell()"<<endl;   }
};
class Mouth
{
        public:
                void eat()
                {   cout<<"Mouth::eat()"<<endl;   }
};
class Ear
{
        public:
                void listen()
                {   cout<<"Ear::listen()"<<endl;   }
};
class Head
{
        public:
                void look()
                {   _eye.look();   }
                void smell()
                {   _nose.smell();   }
                void listen()
                {   _ear.listen();   }
                void eat()
                {   _mouth.eat();   }
        private:
                Eye _eye;
                Nose _nose;
                Mouth _mouth;
                Ear _ear;
};
int main()
{
        Head head;
        head.look();
        head.smell();
        head.listen();
        head.eat();
        return 0;
}
       从逻辑上说，继承是一种a kind of的关系（AKO）或者说IS-A（“是一个”），汽车是车，因此，汽车类可以从普通的车类继承而来，轮子类就不能从汽车类继承来，轮子是汽车的一个部件，轮子可以作为汽车类的对象成员，这就是“组合”（compositioin A has B）。

组合:

软件复用：代码的重复
             ——C语言中采用：函数  宏
             ——C++中采用：继承  组合
★某类以另一个类对象作数据成员，称为组合，在逻辑上，如果类A是类B的一部分（a part of）或者说HAS-A（“有一个”），不要从A类派生出类B，而应当采用组合的方式。

基类与派生类对象间的相互转换：
★“类型适应”是指两种类型之间的关系，说A类适应B类是指A类的对象能直接用于B类对象所能应用的场合，从这种意义上讲，派生类适应于基类，派生类的对象适应于基类对象，派生类对象的指针和引用也适应于基类对象的指针和引用。
      ——可以声明基类的对象等于派生类的对象
      ——可以声明基类的引用等于派生类的对象
      ——可以声明基类的指针指向派生类的对象 (向上转型)
★也就是说如果函数的形参是基类对象或者基类对象的引用或者基类对象的指针类型，在进行函数调用时，相应的实参可以是派生类对象
#include <iostream>
using namespace std;
class Point
{
        public:
                Point(int ix,int iy):_ix(ix),_iy(iy)
                {   cout<<"Point(int,int)"<<endl;   }
                void display()
                {   cout<<"("<<_ix<<","<<_iy<<")"<<endl;   }
        protected:
                int _ix;
                int _iy;
};
class Point3D : public Point
{
        public:
                Point3D(int ix,int iy,int iz):Point(ix,iy),_iz(iz)
                {   cout<<"Point3D(int,int,int)"<<endl;   }
                void display()
                {   cout<<"("<<_ix<<","<<_iy<<","<<_iz<<")"<<endl;   }
        private:
                int _iz;
};
int main()
{
        Point point(1,2);
        point.display();
        Point3D point3d(3,4,5);
        point3d.display();
        cout<<endl;
        point = point3d;  //派生类对象为基类对象赋值
        point.display();
        Point & ref = point3d;   //派生类对象初始化基类对象引用
        ref.display();
        Point * p = & point3d;  //派生类对象地址为基类指针赋值
        p->display();
        return 0;
}

派生类与派生类对象间的相互转换：
★如果用户定义了基类的拷贝构造函数，而没有定义派生类的拷贝构造函数，那么在用一个派生类对象初始化新的派生类对象时，两对象间的派生类部分执行缺省的行为，而两对象间的基类部分执行用户定义的基类拷贝构造函数。
★如果用户重载了基类的对象赋值运算符=，而没有定义派生类的对象赋值运算符，那么在用一个派生类对象给另一个已经存在的派生类对象赋值时，两对象间的派生类部分执行缺省的赋值行为，而两对象间的基类部分执行用户定义的重载赋值函数。

★如果用户定义了派生类的拷贝构造函数或者重载了派生类的对象赋值运算符=，则在用已有派生类对象初始化新的派生类对象时，或者在派生类对象间赋值时，将会执行用户定义的派生类的拷贝构造函数或者重载赋值函数，而不会再自动调用基类的拷贝构造函数和基类的重载对象赋值运算符，这时，通常需要用户在派生类的拷贝构造函数或者派生类的赋值函数中显式调用基类的拷贝构造或赋值运算符函数。

#include <iostream>
#include <string.h>
using namespace std;
class Base
{
        public:
                Base(const char * pbuf):_pbuf(new char[strlen(pbuf)+1])
                {
                        strcpy(_pbuf,pbuf);
                        cout<<"Base(const char *)"<<endl;
                }
                Base(const Base & rhs):_pbuf(new char[strlen(rhs._pbuf)+1])
                {
                        strcpy(_pbuf,rhs._pbuf);
                        cout<<"Base(const Base &)"<<endl;
                }
                Base & operator = (const Base & rhs)
                {
                        cout<<"Base & operator = (const Base &)"<<endl;
                        if(this != &rhs)
                        {
                                delete []_pbuf;
                                _pbuf = new char[strlen(rhs._pbuf)+1];
                                strcpy(_pbuf,rhs._pbuf);
                        }
                        return *this;
                }
                void display()
                {
                        cout<<_pbuf<<endl;
                }
        private:
                char * _pbuf;
};
class Derived : public Base
{
        public:
                Derived(const char * pbuf):Base(pbuf)
                {  cout<<"Derived(const char *)"<<endl;  }
};
int main()
{//当派生类没有定义复制构造函数，而基类显示的定义了复制构造函数，
//则派生类对象之间进行复制时，会自动调用基类复制构造函数
        Derived d1("hello");
        d1.display();
        Derived d2("world");
        d2.display();
        cout<<endl;
        d1=d2;  //派生类使用缺省的赋值构造函数，基类调用用户定义的赋值构造函数
        d1.display();
        d2.display();
        cout<<endl;
        Derived d3 (d1);  //派生类使用缺省的拷贝构造函数，基类调用用户定义的拷贝构造函数
        d3.display();
        return 0;
}
//如果派生类不显示调用基类的拷贝构造函数和赋值构造函数，执行结果就是这样的
#include <iostream>
#include <string.h>
using namespace std;
class Base
{
        public:
                Base():_pbuf(new char[1])
                {   cout<<"Base()"<<endl;   }
                Base(const char * pbuf):_pbuf(new char[strlen(pbuf)+1])
                {
                        strcpy(_pbuf,pbuf);
                        cout<<"Base(const char *)"<<endl;
                }
                Base(const Base & rhs):_pbuf(new char[strlen(rhs._pbuf)+1])
                {
                        strcpy(_pbuf,rhs._pbuf);
                        cout<<"Base(const Base &)"<<endl;
                }

                Base& operator =(const Base & rhs)
                {
                        cout<<"Base & operator = (const Base &)"<<endl;
                        if(this != &rhs)
                        {
                                delete []_pbuf;
                                _pbuf = new char[strlen(rhs._pbuf)+1];
                                strcpy(_pbuf,rhs._pbuf);
                        }
                        return *this;
                }
                ~Base()
                {
                        delete []_pbuf;
                        cout<<"~Base()"<<endl;
                }
                void display()
                {   cout<<_pbuf;   }
        private:
                char * _pbuf;
};
class Derived : public Base
{
        public:
                Derived(const char* pbuf,const char* pbuf2):Base(pbuf),_pbuf2(new char[strlen(pbuf2)+1])
                {
                        cout<<"Derived(const char *,const char *)"<<endl;
                        strcpy(_pbuf2,pbuf2);
                }
                Derived(const Derived & rhs):Base(rhs),_pbuf2(new char[strlen(rhs._pbuf2)+1])
                {//显示调用基类的复制构造函数
                        cout<<"Derived(const char *,const char *)"<<endl;   //这里写错了，导致最后一个结果显示这里了。
                        strcpy(_pbuf2,rhs._pbuf2);
                }
                Derived & operator= (const Derived & rhs)
                {
                        cout<<"Derived & operator = (const Derived &)"<<endl;
                        if(this != &rhs);
                        {
                                Base::operator = (rhs); //显示调用基类的赋值运算符函数
                                delete []_pbuf2;
                                _pbuf2=new char[strlen(rhs._pbuf2)+1];
                                strcpy(_pbuf2,rhs._pbuf2);
                        }
                        return *this;
                }
                ~Derived()
                {
                        delete []_pbuf2;
                        cout<<"~Derived()"<<endl;
                }
                void display()
                {
                        Base::display();
                        cout<<_pbuf2<<endl;
                }
        private:
                char * _pbuf2;
};
int main()
{//当派生类显示定义了复制构造函数，而基类显示定义了复制构造函数，
//则派生类对象之间进行复制时，不会自动调用基类的复制构造函数，
//必须在派生类的复制构造函数之中显示调用基类的复制构造函数。
        Derived d1("hello",",world");
        d1.display();
        Derived d2("shenzhen",",wangdao");
        d2.display();
        cout<<endl;
        d1=d2;
        d1.display();
        d2.display();
        cout<<endl;
        Derived d3=d1;
        d3.display();
        return 0;
}


继承，C++的更多相关文章

  1. javaScript的原型继承与多态性

    1.prototype 我们可以简单的把prototype看做是一个模版,新创建的自定义对象都是这个模版(prototype)的一个拷贝 (实际上不是拷贝而是链接,只不过这种链接是不可见,给人们的感觉 ...

  2. JavaScript的继承实现方式

    1.使用call或apply方法,将父对象的构造函数绑定在子对象上 function A(){ this.name = 'json'; } function B(){ A.call(this); } ...

  3. javascript中的继承与深度拷贝

    前言 本篇适合前端新人,下面开始...... 对于前端新手来说(比如博主),每当对js的对象做操作时,都是一种痛苦,原因就是在于对象的赋值是引用的传递,并非值的传递,虽然看上去后者赋值给了前者,他们就 ...

  4. 谈谈一些有趣的CSS题目（四）-- 从倒影说起，谈谈 CSS 继承 inherit

    开本系列,讨论一些有趣的 CSS 题目,抛开实用性而言,一些题目为了拓宽一下解决问题的思路,此外,涉及一些容易忽视的 CSS 细节. 解题不考虑兼容性,题目天马行空,想到什么说什么,如果解题中有你感觉 ...

  5. JS继承类相关试题

    题目一: //有关于原型继承的代码如下:function Person(name) {   this.name = name;}Person.prototype = {     getName : f ...

  6. JS继承之寄生类继承

    原型式继承 其原理就是借助原型,可以基于已有的对象创建新对象.节省了创建自定义类型这一步(虽然觉得这样没什么意义). 模型 function object(o){ function W(){ } W. ...

  7. JS继承之借用构造函数继承和组合继承

    根据少一点套路,多一点真诚这个原则,继续学习. 借用构造函数继承 在解决原型中包含引用类型值所带来问题的过程中,开发人员开始使用一种叫做借用构造函数(constructor stealing)的技术( ...

  8. JS继承之原型继承

     许多OO语言都支持两种继承方式:接口继承和实现继承.接口继承只继承方法签名,而实现继承则继承实际的方法.如前所述,由于函数没有签名,在ECMAScript中无法实现接口继承.ECMAScript只支 ...

  9. 深入浅出JavaScript之原型链&继承

    Javascript语言的继承机制,它没有"子类"和"父类"的概念,也没有"类"(class)和"实例"(instanc ...

  10. 如果你也会C#，那不妨了解下F#（7）：面向对象编程之继承、接口和泛型

    前言 面向对象三大基本特性:封装.继承.多态.上一篇中介绍了类的定义,下面就了解下F#中继承和多态的使用吧.

随机推荐

  1. 算法笔记--FFT

    推荐阅读资料:算法导论第30章 本文不做证明,详细证明请看如上资料. FFT在算法竞赛中主要用来加速多项式的乘法 普通是多项式乘法时间复杂度的是O(n2),而用FFT求多项式的乘法可以使时间复杂度达到 ...

  2. RNA Spike-in Control（转）

    Spike-in Control:添加/加入(某种物质)的对照(组)在某些情况下,待检验样本中不含待测物质或者含有但是浓度很低,为了证明自己建立的方法能对样本中待测物质进行有效的检测,可在待检样本中加 ...

  3. 关于Mysql 查询所有表的实时记录用于对比2个MySQL 库的数据是否异步

    Xu言: 今天,为了研究一个MySQL主从同步开机后报错 问题,如下图 故障原因分析: 经过分析,可能是主从服务器开机顺序导致.(有待下次断电再次测试) 主从错误提示:日志读取错误的问题.解决方法:更 ...

  4. English trip M1 - AC3 Teacher:Corrine

    课堂上内容 16,black,games The clothes is Only $. is lucky number in China. God give us black eyes,but we ...

  5. 基于AngularJS的Onsen UI --Onsen UI学习笔记

    AngularJS与Onsen UI的结合,Onsen UI应用程序实际上是一个AngularJS 1应用程序. <!doctype html><html lang="en ...

  6. 20 Interesting WPF Projects on CodePlex

    20 Interesting WPF Projects on CodePlex (Some for Silverlight too) Pete Brown - 22 November 2010   I ...

  7. 原生js实现放大镜

    效果: 1.  鼠标放上去会有半透明遮罩.右边会有大图片局部图 2.  鼠标移动时右边的大图片也会局部移动 放大镜的关键原理: 鼠标在小图片上移动时,通过捕捉鼠标在小图片上的位置,定位大图片的相应位置 ...

  8. ddt 实例

    from :https://blog.csdn.net/wushuai150831/article/details/78453549

  9. CentOS7.3将网卡命名方式设置为传统方式

    CentOS7.3将网卡命名方式设置为传统方式 生产环境可能拥有不同系列的操作系统,比如,既有CentOS6系列,也有CentOS7系列的系统,而CentOS6和CentOS7在网卡命名方面有着较大区 ...

  10. STLC - 软件测试生命周期

    什么是软件测试生命周期(STLC)? 软件测试生命周期(STLC)定义为执行软件测试的一系列活动. 它包含一系列在方法上进行的活动,以帮助认证您的软件产品. 图 - 软件测试生命周期的不同阶段 每个阶 ...

热门专题

centos安装taskctl-plugin-kettle
获取时间 与配置时间相差8小时
hashset addall 去重
ubuntu 18.04网卡驱动安装
maven 命令行安装依赖
centos7部署phpipam
835Trie字符串统计
springboot tomcat响应慢
Opecv 二维码的识别率
springboot项目本地md5加密服务器中加密结果
如何设置drawable shape的宽度
C# excel按某一列统计总行数
web页面增删改查属于什么功能
为什么网页版的邮箱关闭了SMTP协议还可以收发邮件
unity itween 下载
win7 64专业版 位安装.net
jquery启动函数
divcss动画上下扫描
谷歌二维码生成java
java jar 开机自启动