C++nbsp;继承

2024-06-19 17:58
文章标签 c++ nbsp 继承

本文主要是介绍C++nbsp;继承，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

注：参考东南大学《C++程序设计教程》视频，主讲老师：何洁月。此内容为自学时所记笔记
第七章   类的继承与派生
继承：保持已有类的特性而构成新类的过程  目的：实现代码重用
派生：在已有类的基础上新增自己的特性而产生新类的过程  目的：原程序进行改造吗
      （1）吸收基类 。（2）改造 同名覆盖。（3）新增加。
基类--->派生类
公有继承：class B{};
          class A:public B{};
          派生类的“成员函数”可以访问基类public ，protected。
          派生类的“对象”只能访问基类的public。
例：
#include
using namespace std;
class Point
{
public :
  //  Point (float x,float y){X=x;Y=y;}
      void InitP(float x,float y){X=x;Y=y;}
      float getX(){return X;}
      float getY(){ return Y;}
      void Print();
      void Move(float x,float y);
private :
      float X,Y;
};
void Point::Move(float x,float y){
      X+=x;
      Y+=Y;
}
void Point::Print(){
          cout<<getX()<<" "<<getY()<<endl;
}
class Rectangle:public Point
{
public :
      void InitR(float x,float y,float w,float h){
              InitP(x,y);
              W=w;
              H=h;
      }
      float getW(){return W;}
      float getH(){return H;}
      //void Print();
private:
        float W,H;
};
int main()
{
        Rectangle r;
        r.InitR(1,1,1,1);
        r.Move(1,1);
        r.Print();
        return 0;
}

私有继承：
    class B{};
    class A:private B{};
    public 和protected 成员以private 出现在派生类中，
    派生类的成员函数不能访问基类的private成员。
    派生类的对象不能访问任何成员，想要访问，必须重新构造方法
  class Rectangle:private Point
{
public :
      void InitR(float x,float y,float w,float h){
              InitP(x,y);
              W=w;
              H=h;
      }
      void Move(float x,float y);    //重新构造
      void Print();                                //重新构造
      float getX(){return Point::getX();}
      float getW(){return W;}
      float getH(){return H;}
      //void Point::Print();
private:
        float W,H;
};
void Rectangle::Move(float x,float y){
    Point::Move(x,y);
}
void Rectangle::Print(){
      Point::Print();
      cout<<W<<"--"<<H<<endl;
}

保护继承（protected）
     class B{};
     class A :protected B{};
     派生类的成员可以访问基类的public，protected
     派生类的对象不能访问基类的所有成员。

     特点与作用：派生类外不能访问基类的protected成员 ，
                 派生类类内可以访问基类的......。
例：
class A
{
public :
      void setA(int aa){a=aa;}
      int getA(){return a;}
protected :
      int a;
};
class B:protected A
{
public :
      int getB(){return b;}
      void changeA(){a=a*2;}    //派生类内可以对基类protected成员操作
      int getA(){A::getA();}
      void setA(int x){A::setA(x);}
private:
            int b;
};
#include
using namespace std;
int main()
{
      B b;
      b.setA(10);
      b.changeA();
      cout<<b.getA()<<endl;
}
总结：三种继承，派生类的成员访问是一样的，派生类的对象访问
      不一样，
      派生类中的成员属性，public->protected->private 变换
              public      protected   private
:public       public      protected   private
:protected    protected   protected   private
:private      private     private     private

protected 对于派生类的对象不能访问，但是派生类内可以访问
一般继承的基类，属性都会protected而不是private

多继承：
      class A{}；
      class B{}；
      class C:public A，private B{};
继承时的构造函数
      基类的构造函数不被继承。
      class A{a};
      A::A(int aa){a=aa;}
      class B{b};
      B::B(int aa,int bb):A(a){b=bb;}
类似于内嵌对象时的构造函数。
  #include
using namespace std;
class A
{
    public :
          A();
          A(int aa);
          ~A();
          int getA(){return a;}
          void Print();
      private:
          int a;
};
A::A(int aa){a=aa;}
A::~A(){cout<<"a xigou"<<endl;}
void A::Print() {cout<<a<<"--"<<endl;}
class B:public A
{
      public :
            B(int aa,int bb);
            ~B();
            void setB(int bb){b=bb;}
            int getB(){return b;}
            void Print();
      private:
            int b;
};
B::B(int aa,int bb):A(aa){    //B的构造函数
    b=bb;
}
B::~B(){cout<<"b xigou"<<endl;}
void B::Print() {A::Print();cout<<b<<"--"<<endl;}
int main()
{
      B b(1,2);
      cout<<b.getA()<<" "<<b.getB()<<endl;
      b.Print();
      return 0;
}
多继承的构造函数
class A{a};
      A::A(int aa){a=aa;}
      class B{b};
      B::B(int aa,int bb,int cc):A(a),C(c){b=bb;}

构造函数的调用次序
   （1）基类：按照他们被继承时的顺序
    （2）成员对象：按照他们在类中声明的顺序
     （3）构造函数体内的内容。
#include
using namespace std;
class C
{
      public :
            C(int cc){c=cc;}
            void setC(int cc){c=cc;}
            int getC(){return c;}
      private:
            int c;
};
class A
{
    public :
          A();
          A(int aa);
          ~A();
          int getA(){return a;}
          void Print();
      private:
          int a;
};
A::A(int aa){a=aa;}
A::~A(){cout<<"a xigou"<<endl;}
void A::Print() {cout<<a<<"--"<<endl;}
class B:public A
{
      public :
            B(int aa,int bb,int cc);
            ~B();
            void setB(int bb){b=bb;}
            int getB(){return b;}
            void Print();
      private:
            int b;
            C c;
};
B::B(int aa,int bb,int cc):A(aa),c(cc){    //B的构造函数
                                                    //先继承，后对象成员，后自己
    b=bb;
}
B::~B(){cout<<"b xigou"<<endl;}
void B::Print() {
      A::Print();cout<<b<<"--"<<endl;
      cout<<c.getC()<<"--"<<endl;
}
int main()
{
      B b(1,2,3);
      cout<<b.getA()<<" "<<b.getB()<<endl;
      b.Print();
      return 0;
}

析构函数 也需派生类自行声明。
         析构顺序与构造函数顺序恰好相反。可以看成栈的使用。

同名覆盖：派生类与基类有相同成员
           class A{fun()};
           class B:public A{fun()};
           b.fun();
           b.A::fun();  //调用基类的成员，
                 
#include
using namespace std;
class A
{
public :
              A(int aa){a=aa;}
              void fun(){cout<<a<<endl;}
private:
              int a;
};
class B :public A
{
public :
            B(int bb,int aa):A(aa){b=bb;}
            void fun(){cout<<b<<endl;}
private:
              int b;
};
int main()
{
      B b(1,2);
      b.fun();
      b.A::fun();
      return 0;
}
继承的二义性问题：
     class A{fun();}
     class B{fun();}
     class C:public A,public B  //A,B有相同的成员名
 解决方法（1）：类名限定
          （2）：同名覆盖
#include
using namespace std;
class A
{
public :
              A(int aa){a=aa;}
              void fun(){cout<<a<<endl;}
              int getA(){return a;}
private:
              int a;
};
class C
{
public :
        C(int cc){c=cc;}
        void fun(){cout<<c<<endl;}
private:
        int c;
};
class B :public A,public C
{
public :
            B(int bb,int aa,int cc):A(aa),C(cc){b=bb;}
            void fun(){cout<<b<<"--"<<getA()<<"---";
                                  C::fun();
                        }
private:
              int b;
};
int main()
{
      B b(1,2,3);
      b.fun();
      b.A::fun();
      b.C::fun();
      return 0;
}

虚基类:只保留基类的一份。
    class B1:virtual public B
作用：解决多继承时可能发生的对同一基类继承多次而产生的二义性问题
      为最远派生类提供唯一的基类成员。不重复产生拷贝。
      B--B1       B-->B2      B1,B2-->C

赋值兼容原则：
    公有派生类对象在使用上可以被当做基类的对象
     赋值，引用，指针。
实际开发实例：
class employee  //基类 员工
{
  protected :
        char *name;
        int id;
        int grade;
        float monthpay;
        static  int employno; //编号最大值
          //静态，所有都可以访问
  public :
          employee();
          ~employee();
          void pay();
          void promote(int );
          void display();
};

class technician:public employee  //技术人员
{
    private :
          float hourlyrate;
          int workHours;
    public :
          technician();
          void pay();
          void display();
};

class salesman:virtual public employee //虚基类,销售人员
{
    protected:
        float comnRate;
        float sales;
      public:
          salesman();
          void pay();
          void display();
};
class manager:virtual public employee//经理
{
    protected:
      float monthlyPay;
    public :
        manager();
        void pay();
        void display();
};
class salesmanager:public salesman,public manager
//销售经理
{
    public :
        salesmanager();
        void pay();
        void display();
};
#include
#include
using namespace std;
int employee::employno=1000;
employee::employee()
{
      char c[50];
      cout<<"输入姓名："<<endl;
      cin>>c;
      name=new char(strlen(c));
      strcpy(name,c);
      employno++;
      id=employno;
      grade=1;
      monthpay=0.0;
}
employee::~employee()
{
      delete name ;//，一开始定义的指针，申请了空间了，释放姓名空间
}
void employee::pay()
{

}
void employee::promote(int increament)
{
      grade+=increament;
}
void employee::display()
{
      cout<<name<<"您好！"<<" 编号："<<id<<" 等级："<<grade<<" 月薪："<<monthpay<<endl;
}
technician::technician()
{
      hourlyrate=10;
}
void technician::pay()
{
      cout<<"请输入 "<<name<<" 本月工作时：";
      cin>>workHours;
      monthpay=hourlyrate*workHours;
}
void technician::display()
{
      employee::display();
      //cout<<"兼职技术人员"<<name<<"编号"<<id<<
    // "级别："<<grade<<"工资"<<monthpay<<endl;
}
salesman::salesman()
{
    comnRate=0.04;
}
void salesman::pay()
{
      cout<<"输入"<<name<<"本月销售额";
      cin>>sales;
      monthpay=sales*comnRate;
}
void salesman::display()
{
      employee::display();
    // cout<<"销售员"<<name<<"编号"<<id<<
    // "级别为"<<grade<<"工资为"<<monthpay<<endl;
}
manager::manager()
{
    //系统自动调用基类的无参构造函数
    monthlyPay=8000;
}
void manager::pay()
{
      monthpay=monthlyPay;
      cout<<"经理底薪："<<monthpay<<endl;
}
void manager::display()
{
      employee::display();
  //cout<<"经理"<<name<<"编号"<<id<<
    // "级别为"<<grade<<"工资为"<<monthpay<<endl;
}
salesmanager::salesmanager()
{
      monthlyPay=5000;
      comnRate=0.005;
}
void salesmanager::pay()
{
      cout<<"请输入"<<name<<"销售额：";
      cin>>sales;
      monthpay=monthlyPay+comnRate*sales;
}
void salesmanager::display()
{
      employee::display();
//  cout<<"销售经理"<<name<<"编号"<<id<<
  //  "级别为"<<grade<<"工资为"<<monthpay<<endl;
}
int main()
{
      manager m1;
      technician t1;
      salesmanager sm1;
      salesman s1;

      m1.promote(3);
      m1.pay();
      m1.display();

      t1.promote(2);
      t1.pay();
      t1.display();

      sm1.promote(1);
      sm1.pay();
      sm1.display();

      s1.pay();
      s1.display();
}

这篇关于C++nbsp;继承的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1075742。

相关文章

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。实现的代码如下： class A class B1:public virtual A; class B2:pu
阅读更多...
C++对象布局及多态实现探索之内存布局（整理的很多链接）

C++对象布局及多态实现探索之内存布局（整理的很多链接）

本文通过观察对象的内存布局，跟踪函数调用的汇编代码。分析了C++对象内存的布局情况，虚函数的执行方式，以及虚继承，等等 文章链接：http://dev.yesky.com/254/2191254.shtml      论C/C++函数间动态内存的传递 (2005-07-30)   当你涉及到C/C++的核心编程的时候，你会无止境地与内存管理打交道。 文章链接：http://dev.yesky
阅读更多...
C++的模板(八)：子系统

C++的模板(八)：子系统

平常所见的大部分模板代码，模板所传的参数类型，到了模板里面，或实例化为对象，或嵌入模板内部结构中，或在模板内又派生了子类。不管怎样，最终他们在模板内，直接或间接，都实例化成对象了。 但这不是唯一的用法。试想一下。如果在模板内限制调用参数类型的构造函数会发生什么?参数类的对象在模板内无法构造。他们只能从模板的成员函数传入。模板不保存这些对象或者只保存他们的指针。因为构造函数被分离，这些指针在模板外
阅读更多...
C++工程编译链接错误汇总VisualStudio

C++工程编译链接错误汇总VisualStudio

目录 一些小的知识点 make工具 可以使用windows下的事件查看器崩溃的地方 dumpbin工具查看dll是32位还是64位的 _MSC_VER .cc 和.cpp 【VC++目录中的包含目录】 vs 【C/C++常规中的附加包含目录】——头文件所在目录如何怎么添加，添加了以后搜索头文件就会到这些个路径下搜索了 include<> 和 include"" WinMain 和
阅读更多...
C/C++的编译和链接过程

C/C++的编译和链接过程

目录 从源文件生成可执行文件（书中第2章） 1.Preprocessing预处理——预处理器cpp 2.Compilation编译——编译器cll ps：vs中优化选项设置 3.Assembly汇编——汇编器as ps：vs中汇编输出文件设置 4.Linking链接——链接器ld 符号 模块，库 链接过程——链接器 链接过程 1.简单链接的例子 2.链接过程 3.地址和
阅读更多...
C++必修：模版的入门到实践

C++必修：模版的入门到实践

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：C++学习 贝蒂的主页：Betty’s blog 1. 泛型编程 首先让我们来思考一个问题，如何实现一个交换函数？ void swap(int& x, int& y){int tmp = x;x = y;y = tmp;} 相信大家很快就能写出上面这段代码，但是如果要求这个交换函数支持字符型
阅读更多...
C++入门01

C++入门01

1、.h和.cpp 源文件 (.cpp)源文件是C++程序的实际实现代码文件，其中包含了具体的函数和类的定义、实现以及其他相关的代码。主要特点如下：实现代码: 源文件中包含了函数、类的具体实现代码，用于实现程序的功能。编译单元: 源文件通常是一个编译单元，即单独编译的基本单位。每个源文件都会经过编译器的处理，生成对应的目标文件。包含头文件: 源文件可以通过#include指令引入头文件，以使
阅读更多...
C++面试八股文：std::deque用过吗？

C++面试八股文：std::deque用过吗？

100编程书屋_孔夫子旧书网 某日二师兄参加XXX科技公司的C++工程师开发岗位第26面： 面试官：deque用过吗？ 二师兄：说实话，很少用，基本没用过。 面试官：为什么？ 二师兄：因为使用它的场景很少，大部分需要性能、且需要自动扩容的时候使用vector，需要随机插入和删除的时候可以使用list。 面试官：那你知道STL中的stack是如何实现的吗？ 二师兄：默认情况下，stack使
阅读更多...
剑指offer（C++）--孩子们的游戏(圆圈中最后剩下的数)

剑指offer（C++）--孩子们的游戏(圆圈中最后剩下的数)

题目 每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去
阅读更多...
剑指offer（C++）--扑克牌顺子

剑指offer（C++）--扑克牌顺子

题目 LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为1
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2