C++基础知识

2.类的作用域运算符

shadow

在我们之前讲的内容中，我们会发现一种情况，就是在我们在不同类中的打印函数我们都是尽量让其名字不同，那么为什么会有这种情况呢？首先我们来看一个函数

void func()

    {

        cout<<"B::void func()"<<endl;

        func();

    }

运行程序会发现这是一个死循环，因为其存在自己调用自己的情况，那么放在类中会是什么样子的呢

#include <iostream>

using namespace std;

class A

{

public:

    void foo()

    {

        cout<<"A::void foo()"<<endl;

    }

};

class B:public A

{

public:

    void foo()

    {

        cout<<"B::void foo()"<<endl;

        foo();//实际上这里是有一个this指针指向foo的

    }

};

int main()

{

    B b;

    b.foo();

    return ;

}

这样调用还是会出现死循环的情况，虽然其本意是在类B中的foo调用类A中的foo，但是由于this指针指向foo并且由于类中的两个函数重名，因此会出现死循环，为了解决这个问题，引入类的作用域运算符，将类B中的foo函数写成如下形式

void foo()

    {

        cout<<"B::void foo()"<<endl;

        A::foo();

    }

shadow产生机理

（1）在父子类中出现重名的标识符（函数成员和数据成员），就会构成shadow，如果想访问被shadow的成员，加上父类的命名空间

（2） shadow在父子类中的标识符只有一个，就是重名，不论返回值，参数不同什么

3. 继承的方式详解

继承的方式有三种：public,protected和private,但是我们一般都用public

所有的继承必须是public的，如果想私有继承的话，应该采用将基类实例作为成员的方式作为替代

一般情况下，在一个类中，public常用于接口，protected常用于数据，private常用于隐私

那么为什么public是用的最多的呢

如果多级派生中，均采用public，直到最后一级，派生类中均可访问基类的public,protected，很好的做到了接口的传承，保护数据以及隐私的保护

protected：封杀了对外的接口，保护数据成员，隐私保护

public：传承接口，间接地传承了数据（protected）

protected:传承数据，间接封杀了对外接口（public）

private:统杀了数据和接口

4. 类的作用域运算符

shadow产生机理

（1）在父子类中出现重名的标识符（函数成员和数据成员），就会构成shadow，如果想访问被shadow的成员，加上父类的命名空间

（2） shadow在父子类中的标识符只有一个，就是重名，不论返回值，参数不同什么

5. 多重继承

从继承类别来说，继承可以分为单继承和多继承

多继承的意义：

俗话讲，鱼和熊掌不可兼得，而在计算机中可以实现，生成一种新的对象，叫熊掌鱼，多继承自鱼和熊掌即可

继承语法：

派生类名：public 基类名1，public 基类名2，…，protected 基类名n

构造器格式

派生类名：派生类名（总参列表）

:基类名1（参数表1），基类名2（参数名2）,…基类名n（参数名n）,

内嵌子对象1（参数表1），内嵌子对象2（参数表2）…内嵌子对象n（参数表n）

{

派生类新增成员的初始化语句

}

多继承可能存在的问题

（1）三角问题

多个父类中重名的成员，继承到子类中后，为了避免冲突，携带了各父类的作用域信息，子类中要访问继承下来的重名成员，则会产生二义性，为了避免冲突，访问时需要提供父类的作用域信息

构造器问题

下面我们用一个实际的例子来对其进行讲解

 #include <iostream>

 using namespace std;

 class X

 {

 public:

     X(int d)

     {

         cout<<"X()"<<endl;

     }

 protected:

     int _data;

 };

 class Y

 {

 public:

     Y(int d)

     {

         cout<<"Y()"<<endl;

     }

 protected:

     int _data;

 };

 class Z:public X,public Y

 {

 public:

     Z()

         :X(),Y()

     {

     }

     void dis()

     {

         cout<<Y_data<<endl;     }

 };

 int main()

 {

     Z z;

     z.dis();

     return ;

 }

直接这样的话会报错，因为_data会产生二义性，为了解决这个问题，我们可以在数据之前加上其父类作用域

 void dis()

     {

         cout<<Y::_data<<endl;

         cout<<X::_data<<endl;

     }

下面我们看一个有趣的情况

#include <iostream>

using namespace std;

class X

{

public:

    X(int d)

    {

        cout<<"X()"<<endl;

        _data=d;

    }

    void setData(int d)

    {

        _data=d;

    }

protected:

    int _data;

};

class Y

{

public:

    Y(int d)

    {

        cout<<"Y()"<<endl;

        _data=d;

    }

    int getData()

    {

        return _data;

    }

protected:

    int _data;

};

class Z:public X,public Y

{

public:

    Z(int i,int j)

        :X(i),Y(j)

    {

    }

    void dis()

    {

        cout<<X::_data<<endl;

        cout<<Y::_data<<endl;

    }

};

int main()

{

    Z z(,);

    z.dis();

    cout<<"================="<<endl;

    z.setData();

    cout<<z.getData()<<endl;

    cout<<"================="<<endl;

    z.dis();

    return ;

}

在这里我们getData得到的数据仍然是200，并不是setData的1000000，原因如下

刚开始的时候，在类X和类Y中，都有一个_data，

当其继承在类Z中后

由于是重名的问题，setData设置的是类X中的数据，但是getData得到的是类Y中的数据，所以说会出现问题

那么我们应该怎么来解决这个问题呢

需要解决的问题：

数据冗余

访问方便

由此引发了一个三角转四角的问题

提取各父类中相同的成员，包括数据成员和函数成员，构成祖父类
让各父类，继承祖父类
虚继承是一种继承的扩展,virtual

首先解决初始化问题，

祖父类的好处是，祖父类是默认的构造器，因此在父类中，并不需要显示地调用，按道理说，Z中有类X,Y，只需要管X,Y的初始化就可以了

#include <iostream>

using namespace std;

//祖父类

class A

{

protected:

    int _data;

};

//父类继承祖父类

class X:virtual public A

{

public:

    X(int d)

    {

        cout<<"X()"<<endl;

        _data=d;

    }

    void setData(int d)

    {

        _data=d;

    }

};

//各父类继承祖父类

class Y:virtual public A

        //虚继承

{

public:

    Y(int d)

    {

        cout<<"Y()"<<endl;

        _data=d;

    }

    int getData()

    {

        return _data;

    }

};

class Z:public X,public Y

{

public:

    Z(int i,int j)

        :X(i),Y(j)

    {

    }

    void dis()

    {

        cout<<_data<<endl;

    }

};

int main()

{

    Z z(,);

    z.dis();

    cout<<"================="<<endl;

    z.setData();

    cout<<z.getData()<<endl;

    cout<<"================="<<endl;

    z.dis();

    return ;

}

这样就带来了两个好处，解决了数据冗余的问题，并且为访问带来了便利，虚继承也是一种设计的结果，被抽象上来的类叫做虚基类。也可以说成：被虚继承的类称为虚基类

虚基类：被抽象上来的类叫做虚基类

虚继承：是一种对继承的扩展

那么虚继承就有几个问题需要我们来注意了，首先是初始化的顺序问题，为了测试初始化的顺序问题，因为上述都是构造器的默认情况，但是实际情况中，可能都会带参数，甚至是虚继承的祖父类也会带参数，那么构造器顺序又将是如何的呢？我们利用如下代码进行测试

 #include <iostream>

 using namespace std;

 class A

 {

 public:

     A(int i)

     {

         _data=i;

         cout<<"A(int i)"<<endl;

     }

 protected:

     int _data;

 };

 class B:virtual public A

 {

 public:

     B(int i)

         :A(i)

     {

         _data=i;

         cout<<"B(int i)"<<endl;

     }

 };

 class C:virtual public A

 {

 public:

     C(int i)

         :A(i)

     {

         _data=i;

         cout<<"C(int i)"<<endl;

     }

 };

 class D:public C,B

 {

 public:

     D()

         :C(),B(),A()

     {

         cout<<"D(int i)"<<endl;

     }

     void dis()

     {

         cout<<_data<<endl;

     }

 };

 int main()

 {

     D d;

     d.dis();

     return ;

 }

运行代码后我们可以得知，构造的顺序是从祖父类的构造器开始，按照顺序执行下来，最后到孙子类的构造器为止的

当然，上述只是一个测试，因为在实际过程中，祖父类是由父类抽象起来的，因此一般不会用祖父类生成对象

在实际过程中，在父类的构造器中我们常带默认参数，这样我们就可以不使得派生类的构造器如此复杂

实际例子，沙发床，除了上述之外，我们还需要增加颜色和重量，除此之外，我们还需要用descript函数来对其进行描述

#include <iostream>

using namespace std;

class Furniture

{

public:

    void descript()

    {

        cout<<"_weight:"<<_weight<<endl;

        cout<<"_color :"<<_color<<endl;

    }

protected:

    float _weight;

    int _color;

};

class Sofa:virtual public Furniture

{

public:

    Sofa(float w=,int c=)

    {

        _weight=w;

        _color=c;

    }

    void sit()

    {

        cout<<"take a sit and have a rest"<<endl;

    }

};

class Bed:virtual public Furniture

{

public:

    Bed(float w=,int c=)

    {

        _weight=w;

        _color=c;

    }

    void sleep()

    {

        cout<<"have a sleep ......."<<endl;

    }

};

class SofaBed:public Sofa,public Bed

{

public:

    SofaBed(float w,int c)

    {

        _weight=w;

        _color=c;

    }

};

int main()

{

    SofaBed sb(,);

    sb.sit();

    sb.sleep();

    sb.descript();

    return ;

}

int main1()

{

    Sofa sf;

    sf.sit();

    Bed bd;

    bd.sleep();

    return ;

}

6. 多态

（1）生活中的多态

如果有几个相似而不完全相同的对象，有时人们要求在向他们发出同一个消息时，他们的反应各不相同，分别执行不同的操作，这种情况就是多态现象

（2） C++ 中的多态

C++ 中的多态是指，由继承而产生的相关的不同的类，其对同一消息会做出不同的响应

比如，Mspaint中的单击不同图形，执行同一拖动动作而绘制不同的图形，就是典型的多态应用

多态性是面向对象程序设计的一个重要特征，能增加程序的灵活性，可以减轻系统的升级，维护，调试的工作量和复杂度

（3）赋值兼容

赋值兼容是指，在需要基类对象的任何地方，都可以使用共有派生的对象来替代

只有在共有派生类中才有赋值兼容，赋值兼容是一种默认行为，不需要任何的显示的转化步骤

赋值兼容总结起来有以下三种特点

派生类的对象可以赋值给基类对象

派生类的对象可以初始化基类的引用

派生类对象的地址可以赋给指向基类的指针

下面我们将分别对其进行说明

派生类的对象可以赋值给基类对象

观察下面代码

 #include <iostream>

 using namespace std;

 class Shape

 {

 public:

     Shape(int x=,int y=)

         :_x(x),_y(y){}

     void draw()

     {

         cout<<"draw shape from"<<"("<<_x<<","<<_y<<")"<<endl;

     }

 protected:

     int _x;

     int _y;

 };

 class Circle:public Shape

 {

 public:

     Circle(int x=,int y=,int r=)

         :Shape(x,y),_radius(r){}

     void draw()

     {

         cout<<"draw shape from"<<"("<<_x<<","<<_y<<")"<<"radius:"<<_radius<<endl;

     }

 protected:

     int _radius;

 };

 int main()

 {

     Shape s(,);

     s.draw();

     Circle c(,,);

     c.draw();

     s=c; //派生类对象可以赋值给基类对象

     s.draw();

     return ;

 }

有上述例子可以看出，派生类的对象是可以复制给基类对象的

派生类的对象可以初始化基类的引用

 int main()

 {

     Shape s(,);

     s.draw();

     Circle c(,,);

     Shape &rs=c;

     rs.draw();

     return ;

 }

派生类的对象的地址可以赋给指向基类的指针

 int main()

 {

     Shape s(,);

     s.draw();

     Circle c(,,);

     Shape *ps=&c;

     ps->draw();

     return ;

 }

在这三种情况中，使用的最多的是第三种，即派生类对象的地址可以赋给指向基类的指针

就如图示一样，假设左边的类是父类，右边的类是子类，，左边的指针是派生类的对象的地址赋给指向派生类的指针，那么其可访问的范围就是整个派生类，右边的指针是派生类的对象的地址赋给指向基类的指针，那么其访问范围就只有基类的那一部分

7. 多态

多态分为静多态和动多态

静多态，就是我们说的函数重载，表面上，是由重载规则来限定的，内部实现却是Namemangling，此种行为，发生在编译期，故称为静多态

（动）多态，不是在编译阶段决定，而是在运行阶段决定，故称动多态，动多态的形成条件如下

多态实现的条件

父类中有虚函数（加virtual，是一个声明型关键字，即只能在声明中有，在实现中没有），即公用接口

子类override（覆写）父类中的虚函数

通过已被子类对象赋值的父类指针，调用共有接口

下面分别对这些条件进行讲解

父类中有虚函数（加virtual，是一个声明型关键字，即只能在声明中有，在实现中没有），即公用接口

virtual函数是一个声明型关键字，只能在声明中有，在实现中没有

class A

{

public:

    A(){};

    virtual void draw();

private:

    int _x;

}

void A::draw()

{

    cout<<_x<<endl;

}

假设在实现的过程中也加入virtual关键字，即

virtual void A::draw()

{

    cout<<_x<<endl;

}

系统即会开始报错

子类覆写父类中的虚函数，子类中同名同参同函数，才能构成覆写
通过已被子类对象赋值的父类指针，调用虚函数，形成多态

 #include <iostream>

 #include <typeinfo>

 using namespace std;

 class Shape

 {

 public:

     Shape(int x=,int y=)

         :_x(x),_y(y)

     {

         cout<<"shape->this"<<this<<endl;

         cout<<typeid(this).name()<<endl;

     }

     virtual void draw()

     {

         cout<<"draw shape from"<<"("<<_x<<","<<_y<<")"<<endl;

     }

 protected:

     int _x;

     int _y;

 };

 class Circle:public Shape

 {

 public:

     Circle(int x=,int y=,int r=)

         :Shape(x,y),_radius(r)

     {

         cout<<"shape->this"<<this<<endl;

         cout<<typeid(this).name()<<endl;

     }

     void draw()

     {

         cout<<"draw shape from"<<"("<<_x<<","<<_y<<")"<<"radius:"<<_radius<<endl;

     }

 protected:

     int _radius;

 };

 class Rect:public Shape

 {

 public:

     Rect(int x=,int y=,int w=,int l=)

         :Shape(x,y),_width(w),_lenth(l){}

     virtual void draw()

     {

         cout<<"draw Circle from"<<"("<<_x<<","<<_y<<")"

            <<"width:"<<_width<<"lenth:"<<_lenth<<endl;

     }

 protected:

     int _width;

     int _lenth;

 };

 int main()

 {

     Circle c(,,);

     Shape *ps=&c;//父类指针指向子类的对象

     ps->draw();

     Rect r(,,,);

     ps=&r;

     ps->draw();

     return ;

 }

可以看出，利用virtual，可以实现多态

通过父类的指针调用父类的接口指向其本来应该指向的内容

 int main()

 {

     Circle c(,,);

     Shape *ps=&c;//父类指针指向子类的对象

     ps->draw();

     Rect r(,,,);

     ps=&r;

     ps->draw();

     while()

     {

         int choice;

         cin>>choice;

         switch(choice)

         {

             case :

                 ps=&c;

                 break;

             case :

                 ps=&r;

                 break;

         }

         ps->draw();

     }

     return ;

 }

一个接口呈现出不同的行为,其中virtual是一个声明型关键字，用来声明一个虚函数，子类覆写了的函数，也是virtual

虚函数在子函数中的访问属性并不影响多态，要看子类

虚函数和多态总结

（1）virtual是声明函数的关键字，他是一个声明型关键字

（2）override构成的条件，发生在父子类的继承关系中，同名，同参，同返回

（3）虚函数在派生类中仍然为虚函数，若发生覆写，最好显示的标注virtual

（4）子类中覆写的函数，可以为任意的访问类型，依子类需求决定

8. pure virtual function

纯虚函数，指的是virtual修饰的函数，没有实现体，被初始化为0，被高度抽象化的具有纯接口类才配有纯虚函数，含有纯虚函数的类称为抽象基类

抽象基类不能实例化（不能生成对象），纯粹用来提供接口用的

子类中若无覆写，则依然为纯虚，依然不能实例化

9. 总结

（1）纯虚函数只有声明，没有实现，被“初始化”为0

（2）含有纯虚函数的类，称为Abstract Base Class（抽象基类），不能实例化，即不能创造对象，存在的意义就是被继承，而在派生类中没有该函数的意义

（3）如果一个中声明了纯虚函数，而在派生类中没有该函数的定义，则该虚函数在派生类中仍然为虚函数，派生类仍然为纯虚基类

10. 析构函数

含有虚函数的类，析构函数也应该声明为虚函数

这是为了保证对象析构的完整性，具体的情况就是父类的指针指向子类的堆对象，此时通过父类指针去析构子类堆对象时就会虚构不完整，为了保证析构的完整性，含有虚函数的类将其析构函数也声明为虚函数（virtual）

对比栈对象和对对象在多态中销毁的不同

首先我们来看位于栈上的对象

在这里，我们生成了几个类，一个是抽象基类，一个是Dog类，一个是Cat类，我们分别在class中去构造这几个类

首先生成Animal类

其.h文件的内容如下

 #ifndef ANIMAL_H

 #define ANIMAL_H

 class Animal

 {

 public:

     Animal();

     ~Animal();

     virtual void voice()=;

 };

 #endif // ANIMAL_H

其.cpp文件中的内容如下

 #include "animal.h"

 #include <iostream>

 using namespace std;

 Animal::Animal()

 {

     cout<<"Animal::Animal()"<<endl;

 }

 Animal::~Animal()

 {

     cout<<"Animal::~Animal()"<<endl;

 }

然后我们再生成Dog的.h文件

 #ifndef DOG_H

 #define DOG_H

 #include "animal.h"

 class Animal;

 class Dog : public Animal

 {

 public:

     Dog();

     ~Dog();

     virtual void voice();

 };

 #endif // DOG_H

然后我们再生成Dog的.cpp文件

 #include "dog.h"

 #include "animal.h"

 #include <iostream>

 using namespace std;

 Dog::Dog()

 {

     cout<<"Dog::Dog()"<<endl;

 }

 Dog::~Dog()

 {

     cout<<"Dog::~Dog()"<<endl;

 }

 void Dog::voice()

 {

     cout<<"wang wang wang"<<endl;

 }

然后我们生成Cat类

首先生成Cat的.h文件

 #ifndef CAT_H

 #define CAT_H

 #include "animal.h"

 class Cat : public Animal

 {

 public:

     Cat();

     ~Cat();

     virtual void voice();

 };

 #endif // CAT_H

然后再生成cat的.cpp文件

 #include "cat.h"

 #include "animal.h"

 #include <iostream>

 using namespace std;

 Cat::Cat()

 {

     cout<<"Cat::Cat()"<<endl;

 }

 Cat::~Cat()

 {

     cout<<"Cat::~Cat()"<<endl;

 }

 void Cat::voice()

 {

     cout<<"miao miao miao"<<endl;

 }

最后，main函数如下

 #include <iostream>

 #include "animal.h"

 #include "cat.h"

 #include "dog.h"

 using namespace std;

 int main()

 {

     Cat c;

     Dog d;

     Animal *pa=&c;

     pa->voice();

     return ;

 }

生成的结果为

可以看出其是析构完全了的

但是若为栈上的对象，即主函数改写为如下

 #include <iostream>

 #include "animal.h"

 #include "cat.h"

 #include "dog.h"

 using namespace std;

 int main()

 {

     Animal *pa=new Dog;

     pa->voice();

     delete pa;

     return ;

 }

得出的结果为

可以看出其是没有析构完全的，生成的Dog是没有析构的，因此对于堆上的对象，其是析构器有问题的

我们只需要解决如下

但凡类中含有虚函数（包括纯虚函数），将其虚构函数置为virtual ,这样即可以实现完整虚构

12.设计模式的原则：依赖倒置原则－核心思想：面向接口编程

传统的过程式设计倾向于使高层次的模块依赖于低层次的模块（自顶向下，逐步细化），而依据DIP的设计原则，将中间层抽象为抽象层，让高层模块和底层模块依赖于中间层

以一个例子来进行举例，用母亲给给孩子讲故事来进行举例

原本母亲给孩子讲故事是依赖于故事书上的内容，因此对于母亲给孩子讲故事我们可以写成如下代码

 //Mother 依赖于 Book  依赖->耦合    -->低耦合

 class Book

 {

 public:

     string getContents()

     {

         return "从前有座山，山里有座庙，庙里有个小和尚."

                 "听老和尚讲故事，从前有座山";

     }

 };

 class Mother

 {

 public:

     void tellStory(Book &b)

     {

         cout<<b.getContents()<<endl;

     }

 };

在这里，母亲和书的关系是一种强耦合关系

即只要书的内容发生改变，Book,Mother等都需要发生改变，这样是很麻烦的

但是实际上，这种强耦合关系是我们所不希望的，为了解决这种强耦合关系，我们引入一个中间层

 #include <iostream>

 using namespace std;

 //Mother 依赖于 Book  依赖->耦合    -->低耦合

 class IReader

 {

 public:

     virtual string getContents()=;

 };

 class Book:public IReader

 {

 public:

     string getContents()

     {

         return "从前有座山，山里有座庙，庙里有个小和尚."

                 "听老和尚讲故事，从前有座山";

     }

 };

 class NewsPaper:public IReader

 {

 public:

     string getContents()

     {

         return "Trump 要在黑西哥边境建一座墙";

     }

 };

 class Mother

 {

 public:

     void tellStory(IReader *pi)

     {

         cout<<pi->getContents()<<endl;

     }

 };

 int main()

 {

     Mother m;

     Book b;

     NewsPaper n;

     m.tellStory(&b);

     m.tellStory(&n);

     return ;

 }

这样的话，书改变时，Mother是不会发生改变的，只需要加一个新类就是可以的了，用户端接口不会发生改变

虚继承和虚函数总结

虚继承解决了多个父类中重名冗余的成员（包括数据成员和函数成员）

虚函数解决了多态的问题

被虚继承的类称为虚基类，含有纯虚函数的类称为抽象基类

巴特西

C++基础知识－Day8

最新文章

热门文章