继承的概念和意义

类和类之间的关系可以是组合的关系,比如电脑由CPU,内存,硬盘,显卡等待组成,看一个例子

#include <iostream>
#include <string>
using namespace std;
class Memory
{
public:
    Memory()
    {
        cout << "Memory()" << endl;
    }
    ~Memory()
    {
        cout << "~Memory()" << endl;
    }
};

class Disk
{
public:
    Disk()
    {
        cout << "Disk()" << endl;
    }
    ~Disk()
    {
        cout << "~Disk()" << endl;
    }   
};

class CPU
{
public:
    CPU()
    {
        cout << "CPU()" << endl;
    }
    ~CPU()
    {
        cout << "~CPU()" << endl;
    }    
};

class MainBoard
{
public:
    MainBoard()
    {
        cout << "MainBoard()" << endl;
    }
    ~MainBoard()
    {
        cout << "~MainBoard()" << endl;
    }    
};

class Computer
{
    Memory mMem;
    Disk mDisk;
    CPU mCPU;
    MainBoard mMainBoard;
public:
    Computer()
    {
        cout << "Computer()" << endl;
    }
    void power()
    {
        cout << "power()" << endl;
    }
    void reset()
    {
        cout << "reset()" << endl;
    }
    ~Computer()
    {
        cout << "~Computer()" << endl;
    }
};

int main()
{   
    Computer c;
    
    return 0;
}

结果:

Memory()
Disk()
CPU()
MainBoard()
Computer()
~Computer()
~MainBoard()
~CPU()
~Disk()
~Memory()

可以看出组合关系的特点
将其他类的对象作为当类类的成员使用
当前类的对象与成员对象的生命期相同(内存出问题了,电脑就不能开机了)
成员对象在用法上与普通对象完全一致

类和类之间的关系也可以是继承关系,比如惠普电脑类和苹果电脑类继承于电脑类

面向对象中的继承指类之间的父子关系
子类拥有父类的所以属性和行为
子类就是一种特殊的父类
子类对象可以当作父类对象使用
子类中可以添加父类没有的方法和属性
语法:

class Parent
{
   int mv;
   public:
   void method(){};
};
class Child ：public Parent//描述继承关系
{

}

先看一个小例子:

#include <iostream>
#include <string>
using namespace std;
class Parent
{
   int mv;
   public:
   Parent()
   {
     cout<<"Parent()"<<endl;
     mv = 200;
   }
   void method()
   {
     cout<<"mv="<<mv<<endl;
   }
};
class Child : public Parent
{
};
int main()
{
  Child c;
  c.method();
  return 0;
}

结果:

sice@sice:~$ ./a.out 
Parent()
mv=200

Child类继承于Parent类,说明了Child类拥有Parent类所有行为(成员函数)和属性(变量),Parent这个类的构造函数将会被继承,意味着创建Child这个类会调用这个构造函数,看下面的例子

#include <iostream>
#include <string>

using namespace std;

class Parent
{
   int mv;
   public:
   Parent()
   { 
     cout<<"Parent()"<<endl;
     mv = 200;
   }
   void method()
   {
     cout<<"mv="<<mv<<endl;
   }
};
class Child : public Parent
{
  public:
  void hello()
  {
    cout<<"This is in the Child class!"<<endl;
  }
};
int main()
{
  Child c;
  c.hello();
  c.method();
  return 0;
}

结果

sice@sice:~$ ./a.out 
Parent()
This is in the Child class!
mv=200

可以看出继承还有另一个层面的意义,那就是代码复用,子类不但可以继承父类的属性和行为,并且可以在子类重写已有功能,或者添加新功能

重要规则:
子类就是一个特殊的父类
子类对象可以直接初始化父类对象
子类对象可以直接赋值给父类对象

#include <iostream>
#include <string>

using namespace std;

class Parent
{
   int mv;
   public:
   Parent()
   { 
     cout<<"Parent()"<<endl;
     mv = 200;
   }
   void method()
   {
     cout<<"mv="<<mv<<endl;
   }
};
class Child : public Parent
{
  public:
  void hello()
  {
    cout<<"This is in the Child class!"<<endl;
  }
};
int main()
{
  Child c;
  Parent p1 = c;
  Parent p2;
  p2 = c;
  c.hello();
  c.method();
  return 0;
}

编译通过,这是因为Child就是一个特殊的父类,所以它可以当作父类对象来使用,c就是一个Parent对象,赋值给一个Parent对象就是合法的

强化代码:

#include <iostream>
#include <string>

using namespace std;

class Memory
{
public:
    Memory()
    {
        cout << "Memory()" << endl;
    }
    ~Memory()
    {
        cout << "~Memory()" << endl;
    }
};

class Disk
{
public:
    Disk()
    {
        cout << "Disk()" << endl;
    }
    ~Disk()
    {
        cout << "~Disk()" << endl;
    }   
};

class CPU
{
public:
    CPU()
    {
        cout << "CPU()" << endl;
    }
    ~CPU()
    {
        cout << "~CPU()" << endl;
    }    
};

class MainBoard
{
public:
    MainBoard()
    {
        cout << "MainBoard()" << endl;
    }
    ~MainBoard()
    {
        cout << "~MainBoard()" << endl;
    }    
};

class Computer
{
    Memory mMem;
    Disk mDisk;
    CPU mCPU;
    MainBoard mMainBoard;
public:
    Computer()
    {
        cout << "Computer()" << endl;
    }
    void power()
    {
        cout << "power()" << endl;
    }
    void reset()
    {
        cout << "reset()" << endl;
    }
    ~Computer()
    {
        cout << "~Computer()" << endl;
    }
};

class HPBook : public Computer
{
    string mOS;
public:
    HPBook()
    {
        mOS = "Windows 8";
    }
    void install(string os)
    {
        mOS = os;
    }
    void OS()
    {
        cout << mOS << endl;
    }
};

class MacBook : public Computer
{
public:
    void OS()
    {
        cout << "Mac OS" << endl;
    }
};

int main()
{   
    HPBook hp;
    
    hp.power();
    hp.install("Ubuntu 16.04 LTS");
    hp.OS();
    
    cout << endl;
    
    MacBook mac;
    
    mac.OS();
    
    return 0;
}

结果:

sice@sice:~$ ./a.out 
Memory()
Disk()
CPU()
MainBoard()
Computer()
power()
Ubuntu 16.04 LTS

Memory()
Disk()
CPU()
MainBoard()
Computer()
Mac OS
~Computer()
~MainBoard()
~CPU()
~Disk()
~Memory()
~Computer()
~MainBoard()
~CPU()
~Disk()
~Memory()

可以看出我们的代码在main函数中初始化一个hp电脑对象,由于继承于computer类所以会调用父类的构造函数,而且hp对象增加了自己按照系统的函数和获得系统的参数,可见继承是多么灵活