C++继承

1. 继承基类的构造函数

1. 声明：

class Animal
{
public:
	Animal(std::string name);
	~Animal();
private:
	std::string name;
}

class pig : public Animal
{
public:
	pig(std::string name);
	~pig();
private:
	std::string name;
}

2. 定义
   如果子类定义了构造方法，不论是无参数的还是带参数的，在创建子类对象的时候，首先执行父类的无参构造方法，然后执行自己的构造方法。

#include<iostream>
#include<string>

class baseclass
{
public:
    baseclass();
    baseclass(std::string name);
    ~baseclass();
private:
    std::string name;
};

baseclass::baseclass()
{
    std::cout<<"this is baseclass()"<<std::endl;
}

baseclass::baseclass(std::string name)
{
    this->name = name;
    std::cout<<"this is baseclass(std::string name) name is "<<this->name<<std::endl;
}

baseclass::~baseclass()
{
    std::cout<<"this is ~baseclass()"<<std::endl;
}

class subclass : public baseclass
{
public:
    subclass();
    subclass(std::string subname);
    ~subclass();
};

subclass::subclass()
{
    std::cout<<"this is subclass()"<<std::endl;
}

subclass::subclass(std::string subname)
{
    std::cout<<"this is subclass(std::string name) subname is "<<subname<<std::endl;
}

subclass::~subclass()
{
    std::cout<<"this is ~subclass()"<<std::endl;
}

int main()
{
    subclass sub; //  调用类时先调用基类无参构造函数，在调用子类无参构造函数
    subclass sub1("sub1"); // 调用基类无参构造函数，再调用子类有参构造函数

    return 0;
}
// this is baseclass()
// this is subclass()
// this is baseclass()
// this is subclass(std::string name) subname is sub1
// this is ~subclass()
// this is ~baseclass()
// this is ~subclass()
// this is ~baseclass()

在创建子类对象时，如果子类的构造函数没有显示的调用父类的构造函数只定义了自己的有参构造函数，则会出错。（如果父类只有有参构造方法，则子类必须显示的调用此有参构造方法）

// 在创建子类对象时，如果子类的构造函数没有显示的调用父类的构造函数只定义了自己的有参构造函数，
// 则会出错。（如果父类只有有参构造方法，则子类必须显示的调用此有参构造方法）

#include<iostream>
#include<string>

class baseclass
{
public:
    baseclass();
    baseclass(std::string name);
    ~baseclass();
private:
    std::string name;
};

baseclass::baseclass()
{
    std::cout<<"this is baseclass()"<<std::endl;
}

baseclass::baseclass(std::string name)
{
    std::cout<<"this is baseclass(std::string name) name is "<<name<<std::endl;
}

baseclass::~baseclass()
{
    std::cout<<"this is ~baseclass"<<std::endl;
}

class subclass : public baseclass
{
public:
    subclass(std::string name);
    ~subclass();
};

subclass::subclass(std::string name) : baseclass(name)
//若baseclass 中有无参构造函数，则此函数中不写:baseclass(name)也可运行正确
//先调用无参baseclass() 在调用有参subclass(std::string name)构造函数
// 若baseclass 中无无参构造函数，则不写继承程序报错
{
    std::cout<<"this is subclass(std::string name) name is "<<name<<std::endl;
}

// this is baseclass()
// this is subclass(std::string name) name is sub1
// this is ~subclass()
// this is ~baseclass

subclass::~subclass()
{
    std::cout<<"this is ~subclass()"<<std::endl;
}

int main()
{
    subclass sub("sub1");//先调用baseclass(std::string name)构造函数，再调用subclass有参构造函数

    return 0;
}
// this is baseclass(std::string name) name is sub1
// this is subclass(std::string name) name is sub1
// this is ~subclass()
// this is ~baseclass

2. 多继承与多重继承
   多继承：一个派生类有多个基类
   多重继承：一个基类有一个派生类，这个派生类又有一个派生类
   多继承：

//多继承：一个派生类有多个基类

#include<iostream>
#include<string>

class worker
{
public:
    worker(std::string code = "100")
    {
        this->code = code;
        std::cout<<"worker "<<code<<std::endl;
    }
    ~worker()
    {
        std::cout<<"~worker()"<<std::endl;
    }
    void carry()
    {
        std::cout<<this->code<<std::endl;
        std::cout<<"worker-carry()"<<std::endl;
    }

private:
    std::string code;

};

class farmer
{
public:
    farmer(std::string name)
    {
        this->name = name;
        std::cout<<"farmer "<<this->name<<std::endl;
    }
    ~farmer()
    {
        std::cout<<"~farmer()"<<std::endl;
    }
    void sow()
    {
        std::cout<<this->name<<std::endl;
        std::cout<<"farmer-sow()"<<std::endl;
    }
private:
    std::string name;
};

class migrantworker : public worker, public farmer
{
public:
    //调用基类顺序，先调用worker 在调动farmer 最后进入migrantworker 
    migrantworker(std::string code,std::string name):worker(name),farmer(code)//基类不存在默认构造函数，所以要继承基类
    {
        std::cout<<"migrantworker code "<<code<<std::endl;
        std::cout<<"migrantworker name "<<name<<std::endl;
    }
    ~migrantworker()
    {
        std::cout<<"~migrantwork()"<<std::endl;
    }
};

int main()
{
    migrantworker m("10","tt");

    return 0;
}

// worker tt
// farmer 10
// migrantworker code 10
// migrantworker name tt
// ~migrantwork()
// ~farmer()
// ~worker()