标签：float 函数 成员 基类 多态 c++ 派生类 class 构造函数

目录

• 类继承和类派生
• 继承时名字遮蔽
• 基类和派生类的构造函数
• 构造函数调用顺序
• 基类和派生类的析构函数
• 多重继承
• 虚继承和虚基类
• 将派生类赋值给基类（向上转型）
• 将派生类指针赋值给基类指针。
• 将派生类引用赋值给基类引用
• 多态
• 多态的用途
• 纯虚函数 和 抽象类
  • 纯虚函数
  • 抽象类

类继承和类派生

继承(Inheritance): 子类接收父类的产业.
派生(Derive) : 父类把产业传给子类.

继承语法:
class 派生类名: [继承方式] 基类名{
派生类新增成员;
};

#include <iostream>
#include <string>
using namespace std;
class People{
    public:
        void   setname(string name);
        void   setage(int age);
        string getname();
        int    getage();
    private:
        string name;
        int    age;
};

void   People::setname(string name){ this->name = name; }
void   People::setage(int age)     { this->age  = age ; }
string People::getname(){ return this->name; }
int    People::getage() { return this->age ; }

class Student: public People{ //公有继承
    public:
        void  setscore(float score);
        float getscore();
        void  show();
    private:
        float score;
};
void  Student::setscore(float score){ this->score = score; }
float Student::getscore(){ return this->score; }
void  Student::show(){
    cout << "name=" << this->getname() << ", age=" << this->getage() << ", score=" << this->getscore() << endl;
}

int main(){
    Student *p_stu0 = new Student; //通过new关键字返回的是指针
    p_stu0->setname("Xiaoming");   //指针通过->调用成员
    p_stu0->setage(17);
    p_stu0->setscore(95.2);
    p_stu0->show();

    Student stu1;             //没有new, 返回的是对象.
    stu1.setname("XiaoHong"); //对象通过"."调用成员
    stu1.setage(18);
    stu1.setscore(59.2);
    stu1.show();
}

继承方式有三种: public, protect, private.

不同继承方式, 基类成员在派生类中的属性

继承方式	public成员	protected成员	private成员
public 继承	public	protected	不可见
protect继承	protected	protected	不可见
private继承	private	private	不可见

继承方式中的public、protected、private是用来指明基类成员在派生类中的最高访问权限的.
不管继承方式如何，基类中的private成员在派生类中始终不能使用
如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为 public 或 protected；只有那些不希望在派生类中使用的成员才声明为 private
如果希望基类的成员既不向外暴露（不能通过对象访问），还能在派生类中使用，那么只能声明为 protected。

由于 private 和 protected 继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中我们一般使用 public.

使用 using 关键字可以改变基类成员在派生类中的访问权限，例如将 public 改为 private、将 protected 改为 public。
注意：using 只能改变基类中 public 和 protected 成员的访问权限，不能改变 private 成员的访问权限，因为基类中 private 成员在派生类中是不可见的，根本不能使用，所以基类中的 private 成员在派生类中无论如何都不能访问。

继承时名字遮蔽

如果派生类中的成员（包括成员变量和成员函数）和基类中的成员重名，那么就会遮蔽从基类继承过来的成员。所谓遮蔽，就是在派生类中使用该成员（包括在定义派生类时使用，也包括通过派生类对象访问该成员）时，实际上使用的是派生类新增的成员，而不是从基类继承来的。

比如父类People和派生类Student中都定义了函数show(), 则
stu.show() 调用的是派生类的成员.
stu.People::show()调用的是父类的成员.

注意: 父类与派生类名称一样的函数不构成重载, 只要名字相同就会遮蔽, 不管参数是否相同.

基类和派生类的构造函数

构造函数不能继承, 所有一般需要在派生类的构造函数中调用基类的构造函数.
因为基类构造函数不会被继承，不能当做普通的成员函数来调用, 只能在初始化列表中使用.

#include <iostream>
using namespace std;
class People{
    public:
        People(string name, int age);
        void show();
    protected:
        string m_name;
        int m_age;
};
People::People(string name, int age): m_name(name), m_age(age) {}
void People::show(){
    cout << "name=" << m_name << ", age=" << m_age << endl;
}

class Student: public People{
    public:
        Student(string name, int age, float score);
        void show();
    private:
        float m_score;
};

//定义派生类的构造函数
//Student::Student(string name, int age, float score): People(name, age), m_score(score){} //此句没问题
Student::Student(string name, int age, float score): People(name, age){ //在初始化列表中调用基类构造函数
    //People(name, age); //此句是错的, 因为基类构造函数不会被继承，不能当做普通的成员函数来调用, 只能在初始化列表中使用
    m_score = score;
}
void Student::show(){
    cout << "name=" << m_name << ", age=" << m_age << ", score=" << m_score << endl;
}

int main(){
    Student stu0("XiaoMing", 13, 19.8);
    stu0.show();
}

构造函数调用顺序

构造函数的调用顺序是按照继承的层次自顶向下、从基类再到派生类的。
还有一点要注意，派生类构造函数中只能调用直接基类的构造函数，不能调用间接基类的。
事实上，通过派生类创建对象时必须要调用基类的构造函数，这是语法规定。换句话说，定义派生类构造函数时最好指明基类构造函数；如果不指明，就调用基类的默认构造函数（不带参数的构造函数）；如果没有默认构造函数，那么编译失败。

基类和派生类的析构函数

和构造函数类似，析构函数也不能被继承。与构造函数不同的是，在派生类的析构函数中不用显式地调用基类的析构函数，因为每个类只有一个析构函数，编译器知道如何选择，无需程序员干涉。

多重继承

一个派生类可以有多个基类.
多继承容易让代码逻辑复杂、思路混乱，一直备受争议，中小型项目中较少使用，后来的 Java、C#、PHP 等干脆取消了多继承。

多继承语法:
class 派生类名称: [继承类型] 基类A, [继承类型] 基类B[, ...]{
派生类成员;
};

虚继承和虚基类

虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。其中，这个被共享的基类就称为虚基类（Virtual Base Class），本例中的 A 就是一个虚基类。在这种机制下，不论虚基类在继承体系中出现了多少次，在派生类中都只包含一份虚基类的成员。

将派生类赋值给基类（向上转型）

数据类型转换的前提是，编译器知道如何对数据进行取舍.

类其实也是一种数据类型，也可以发生数据类型转换，不过这种转换只有在基类和派生类之间才有意义，并且只能将派生类赋值给基类，包括
1)将派生类对象赋值给基类对象、
2)将派生类指针赋值给基类指针、
3)将派生类引用赋值给基类引用，
这在 C++ 中称为向上转型（Upcasting）。

相应地，将基类赋值给派生类称为向下转型（Downcasting）。

赋值的本质是将现有的数据写入已分配好的内存中，对象的内存只包含了成员变量，所以对象之间的赋值是成员变量的赋值，成员函数不存在赋值问题。
运行结果也有力地证明了这一点，虽然有a=b;这样的赋值过程，但是 a.display() 始终调用的都是 A 类的 display() 函数。
换句话说，对象之间的赋值不会影响成员函数，也不会影响 this 指针。
将派生类对象赋值给基类对象时，会舍弃派生类新增的成员，也就是“大材小用”

将派生类指针赋值给基类指针。

与对象变量之间的赋值不同的是，对象指针之间的赋值并没有拷贝对象的成员，也没有修改对象本身的数据，仅仅是改变了指针的指向。
将派生类指针赋值给基类指针时，通过基类指针只能使用派生类的成员变量，但不能使用派生类的成员函数.

编译器虽然通过指针的指向来访问成员变量，但是却不通过指针的指向来访问成员函数：编译器通过指针的类型来访问成员函数。
对于 pa，它的类型是 A，不管它指向哪个对象，使用的都是 A 类的成员函数

总结:

1. 编译器通过指针来访问成员变量，指针指向哪个对象就使用哪个对象的数据；
2. 编译器通过指针的类型来访问成员函数，指针属于哪个类的类型就使用哪个类的函数。

将派生类引用赋值给基类引用

多态

“多态（polymorphism）”指的是同一名字的事物可以完成不同的功能。
多态可以分为编译时的多态和运行时的多态。
编译时的多态: 主要是指函数的重载（包括运算符的重载）、对重载函数的调用，在编译时就能根据实参确定应该调用哪个函数，因此叫编译时的多态；
运行时的多态: 和继承、虚函数等概念有关，是本章要讲述的内容。本教程后面提及的多态都是指运行时的多态。

有了虚函数，基类指针指向基类对象时就使用基类的成员（包括成员函数和成员变量），指向派生类对象时就使用派生类的成员。换句话说，基类指针可以按照基类的方式来做事，也可以按照派生类的方式来做事，它有多种形态，或者说有多种表现方式，我们将这种现象称为多态（Polymorphism）。

多态是面向对象编程的主要特征之一，C++中虚函数的唯一用处就是构成多态。
C++提供多态的目的是：可以通过基类指针对所有派生类（包括直接派生和间接派生）的成员变量和成员函数进行“全方位”的访问，尤其是成员函数。如果没有多态，我们只能访问成员变量。

多态的用途

//虚函数的注意事项:

1. 只需要在虚函数的声明处加上 virtual 关键字，函数定义处可以加也可以不加。
2. 为了方便，你可以只将基类中的函数声明为虚函数，这样所有派生类中具有遮蔽关系的同名函数都将自动成为虚函数。
3. 当在基类中定义了虚函数时，如果派生类没有定义新的函数来遮蔽此函数，那么将使用基类的虚函数。
4. 只有派生类的虚函数覆盖基类的虚函数（函数原型相同）才能构成多态（通过基类指针访问派生类函数）
5. 构造函数不能是虚函数. 对于基类的构造函数,它仅仅是在派生类构造函数中被调用,这种机制不同于继承.也就是说,派生类不继承基类的构造函数,将构造函数声明为虚函数没有什么意义.
6. 析构函数可以声明为虚函数，而且有时候必须要声明为虚函数，这点我们将在下节中讲解。

//构成多态的条件

1. 必须存在继承关系;
2. 继承关系中必须有同名的函数, 并且它们是覆盖关系;
3. 存在基类的指针, 通过该指针调用虚函数;

#include <iostream>
class Base{
    public:
        virtual void func();
        virtual void func(int n);
};
void Base::func(){ std::cout << "In Base::func()" << std::endl; }
void Base::func(int n){ std::cout << "In Base::func(int n)" << std::endl; }

class Derived: public Base{
    public:
        void func();
        void func(std::string str);
};
void Derived::func(){ std::cout << "In Derived::func()" << std::endl; }
void Derived::func(std::string str){ std::cout << "In Derived::func(std::string str)" << std::endl; }

int main(){
    Base *p = new Derived; //指针p是基类类型, 但指向派生类.

    p->func(); //调用派生类的虚函数, 构成了多态;
    p->func(6);//调用基类的虚函数, 因为派生类中没有覆盖它;
    //p->func("name"); //编译错误, 因为基类的指针只能访问从基类继承过去的成员, 不能访问新增的成员.
}

纯虚函数 和 抽象类

纯虚函数

声明方法: virtual 返回值类型 函数名(函数参数) = 0;
特点: 只有函数声明, 没有函数体, 函数声明时在结尾加了=0;

抽象类

概念: 包含纯虚函数的类称为抽象类.
特点: 抽象类无法实例化(无法创建对象), 因为纯虚函数没有函数体, 无法调用, 无法分配内存空间;
作用: 抽象类通常是做为基类, 让派生类去实现纯虚函数. 派生类必须实现纯虚函数才能被实例化;

#include <iostream>
class Line{
    public:
        Line(float len);
        virtual float area() = 0;
        virtual float volume() = 0;
    protected:
        float m_len;
};
Line::Line(float len): m_len(len){}

class Rec: public Line{
    public:
        Rec(float len, float width);
        float area();
    protected:
        float m_width;
};
Rec::Rec(float len, float width): Line(len), m_width(width){}
float Rec::area(){
    return m_len * m_width;
}

class Cuboid: public Rec{
    public:
        Cuboid(float len, float width, float height);
        float area();
        float volume();
    protected:
        float m_height;
};
Cuboid::Cuboid(float len, float width, float height): Rec(len, width), m_height(height){}
float Cuboid::area(){
    return 2*(m_len*m_width + m_len*m_height + m_width*m_height);
}
float Cuboid::volume(){
    return m_len*m_width*m_height;
}

class Cube: public Cuboid{
    public:
        Cube(float len);
        float area();
        float volume();
};
Cube::Cube(float len): Cuboid(len, len, len){}
float Cube::area(){
    return 6*m_len*m_len;
}
float Cube::volume(){
    return m_len*m_len*m_len;
}


int main(){
    Line *p_cuboid = new Cuboid(10, 20, 30);
    Line *p_cube   = new Cube(15);

    std::cout << "Cuboid.area()  =" << p_cuboid->area() << std::endl;
    std::cout << "Cuboid.volume()=" << p_cuboid->volume() << std::endl;

    std::cout << "Cube.area()  =" << p_cube->area() << std::endl;
    std::cout << "Cube.volume()=" << p_cube->volume() << std::endl;
}

在实际开发中，你可以定义一个抽象基类，只完成部分功能，未完成的功能交给派生类去实现（谁派生谁实现）。这部分未完成的功能，往往是基类不需要的，或者在基类中无法实现的。虽然抽象基类没有完成，但是却强制要求派生类完成，这就是抽象基类的“霸王条款”。

抽象基类除了约束派生类的功能，还可以实现多态。请注意第 51 行代码，指针 p 的类型是 Line，但是它却可以访问派生类中的 area() 和 volume() 函数，正是由于在 Line 类中将这两个函数定义为纯虚函数；如果不这样做，51 行后面的代码都是错误的。我想，这或许才是C++提供纯虚函数的主要目的。

注意:

1. 一个纯虚函数就可以使类成为抽象基类，但是抽象基类中除了包含纯虚函数外，还可以包含其它的成员函数（虚函数或普通函数）和成员变量。
2. 只有类中的虚函数才能被声明为纯虚函数，普通成员函数和顶层函数均不能声明为纯虚函数。

标签：float,函数,成员,基类,多态,c++,派生类,class,构造函数
来源： https://www.cnblogs.com/gaiqingfeng/p/16463261.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。