this指针 和 类的继承

一、this指针

• Human类的属性fishc与Human（）构造器的参数fishc同名，但却是两个东西。
• 使用this指针让构造器知道哪个是参数，哪个是属性。

this指针：指向当前的类生成的对象

this -> fishc = fishc

当前对象（this）的属性（fishc ） = 参数 （fishc ）

现在编译器就懂了，赋值操作符的左边将被解释为当前对象的 fishc 属性，右边将被解释为构造器的传入来的 fishc 参数。
注意： 使用 this 指针的基本原则是：如果代码不存在二义性隐患，就不必使用 this 指针！

---

---

二、类的继承

C++ 类的继承允许一个类（派生类 / 子类）获取另一个类（基类 / 父类）的属性和方法，实现代码复用与扩展。

**（1）语法：**class 子类名：继承方式 父类名{...}

class Pig:public Animal{...}

（2）案例

假设我们有一只乌龟和一只猪，它们都有一些共同特征：例如都有嘴巴会吃东西，都睡觉，都看会流口。
当然，它们也有不同的地方：例如乌龟会游泳，猪会爬树。。。。。。

---

那么我们就需要编写一个 Animal 类作为 Turtle类和 Pig 类的基类。
• 基类： 是可以派生出其他的类，也称为父类或超类。比如这里的 Animal 类是基类。
**• 子类：**是从基类派生出来的类，比如这里的 Turtle类和 Pig 类是子类。

#include <iostream>
#include <string>

//父类 
class Animal
{
public:
    std::string mouth;

    void eat(); //方法声明 
    void sleep();
    void drool();
};

//子类Pig类 
class Pig : public Animal
{
public:
    void climb();
};

//子类Turtle类 
class Turtle : public Animal
{
public:
    void swim();
};

//方法定义 
void Animal::eat()
{
    std::cout << "I'm eatting!" << std::endl;
}

void Animal::sleep()
{
    std::cout << "I'm sleeping!Don't disturb me!" << std::endl;
}

void Animal::drool()
{
    std::cout << "我是公的，看到母的我会流口水，我正在流口水。。。" << std::endl;
}

void Pig::climb()
{
    std::cout << "我是一个只漂亮的小母猪猪，我会上树，我正在爬树，嘘。。。" << std::endl;
}

void Turtle::swim()
{
    std::cout << "我是一只小甲鱼，当母猪想抓我的时候，我就游到海里。。哈哈。。" << std::endl;
}

int main()
{
    Pig pig;
    Turtle turtle;

    pig.eat();
    turtle.eat();
    pig.climb();
    turtle.swim();

    return 0;
}

（3）继承方式（public、private、protected）

• 公有继承（public） ：基类的公有和保护成员在派生类里保持原访问权限，私有成员不可直接访问。
• 私有继承（private） ：基类的公有和保护成员在派生类中变为私有成员,基类的私有成员在派生类中仍然不可直接被其他类访问。
• 保护继承（protected） ：基类的公有和保护成员在派生类中变为保护成员，基类的私有成员在派生类中不可直接被其他类访问。

链接：访问控制--public、protected、private-CSDN博客

（4）派生类的构造函数和析构函数 的 执行顺序

• 派生类的构造函数会先调用基类的构造函数，然后再执行自身的构造函数体；
• 析构函数的执行顺序则相反，先执行派生类的析构函数，再执行基类的析构函数。

#include <iostream>
#include <string>

//父类 
class BaseClass
{
public:
    BaseClass(); //父类构造器声明 
    ~BaseClass();//父类析构函数声明 

    void doSomething();//父类函数声明 
};

//子类 
class SubClass : public BaseClass
{
public:
    SubClass();//子类构造器声明 
    ~SubClass();//子类析构函数声明 
};
//父类构造函数定义 
BaseClass::BaseClass()
{
    std::cout << "进入基类构造器。。。。。\n";
    std::cout << "我在基类构造器里边干了某些事。。。。\n\n";
}
//父类析构函数定义 
BaseClass::~BaseClass()
{
    std::cout << "进入基类析构器.......\n";
    std::cout << "我在基类析构器里边也干了某些事。。。。\n\n";
}
//父类函数声明 
void BaseClass::doSomething()
{
    std::cout << "我干了某些事。。。。\n\n";
}
//子类构造函数定义 
SubClass::SubClass()
{
    std::cout << "进入子类构造器.....\n";
    std::cout << "我在子类构造器里边还干了某些事．．．．．\n\n";
}
//子类析构函数定义 
SubClass::~SubClass()
{
    std::cout << "进入子类析构器......\n";
}

int main()
{
    SubClass subclass;
    subclass.doSomething();

    std::cout << "完事，收工!\n";

    return 0;
}

（5）带有参数的构造器的继承

定义子类构造函数时：

Animal::Animal( std::string theName ){
    name = theName;
}
Pig::Pig( std::string theName ) : Animal( theName ){
}

#include <iostream>
#include <string>

class Animal
{
public:
    std::string mouth;
    std::string name;//名字 

    Animal(std::string theName); //父类有参构造器 声明 
    void eat();
    void sleep();
    void drool();
};

class Pig : public Animal
{
public:
    void climb();
    Pig(std::string theName); //Pig子类有参构造器 声明 
};

class Turtle : public Animal
{
public:
    void swim();
    Turtle(std::string theName); //Turtle子类有参构造器 
};
//父类有参构造函数定义 
Animal::Animal(std::string theName)
{
    name = theName;
}

void Animal::eat()
{
    std::cout << "I'm eatting!" << std::endl;
}

void Animal::sleep()
{
    std::cout << "I'm sleeping!Don't disturb me!" << std::endl;
}

void Animal::drool()
{
    std::cout << "我是公的，看到母的我会流口水，我正在流口水。。。" << std::endl;
}
//Pig子类有参构造函数定义 
Pig::Pig(std::string theName) : Animal(theName)  //重点！！！ 
{
}

void Pig::climb()
{
    std::cout << "我是一个只漂亮的小母猪猪，我会上树，我正在爬树，嘘。。。" << std::endl;
}
//Turtle子类有参构造函数定义 
Turtle::Turtle(std::string theName) : Animal(theName) //重点！！！ 
{
}

void Turtle::swim()
{
    std::cout << "我是一只小甲鱼，当母猪想抓我的时候，我就游到海里。。哈哈。。" << std::endl;
}

int main()
{
    Pig pig("小猪猪");
    Turtle turtle("小甲鱼");

    std::cout << "这只猪的名字是: " << pig.name << std::endl;
    std::cout << "每只乌龟都有个伟大的名字: " << turtle.name << std::endl;

    pig.eat();
    turtle.eat();
    pig.climb();
    turtle.swim();

    return 0;
}

注意在子类的构造器定义里的" :Animal(theName)" 语法含义是：

• -- 当调用 Pig （） 构造器时（以 theName 作为输入参数）， Animal （）构造器也将被调用（ theName 输入参数将传递给它）。
• -- 于是，当我们调用 Pig pig(" 小猪猪" ); 将把字符串 "小猪猪" 传递给 Pig （） 和 Animal （），赋值动作将实际发生在 Animal （） 方法里。

（6）C++ 支持多重继承，即一个子类可以继承多个父类。

---

---

未完待续。。。