【c++】访问控制、覆盖方法和重载方法

一、访问控制

访问级别

级别	允许谁来访问
public	任何代码
protected	这个类本身和它的子类
private	只有这个类本身

关于从基类继承来的方法和属性的保护

    class pig ：public Animal{…}

C++不仅允许你对在类里定义的方法和属性实施访问控制，还允许你控制子类可以访问基类里的那些方法和属性

public：

告诉编译器，继承的方法和属性的访问级别不发生任何改变-即public仍然能被任何代码访问，protected只能由基类本身及其子类访问，private只能由基类本身访问。

protectd：

把基类的访问级别改为protected，如果原来是public的话，这将使得这个子类外部的代码无法通过子类去访问基类中的public。

private：

是在告诉编译器，从基类继承过来的没一个成员都当成private来对待，这意味着只有这个子类可以使用它从基类继承过来的元素(那么基类本身呢？不太懂)

二、覆盖方法

//我们声明Animal这个类,子类Pig和Bird都继承自Animal类,
//猪和鸟动的方式自然不同,所以要对父类方法进行覆盖
//首先在子类中将要覆盖的方法再声明一次,再实现一次,这就是方法覆盖。

#include<iostream>

class Animal
{
public:
        void move();
};

class Pig : Animal
{
public:
        void move();//覆盖，参数类型个数及返回值必须完全一样
};

class Bird : Animal
{
public:
        void move();
};

void Animal :: move()
{
    std::cout << "我会动哦\n";
}

void Pig :: move()
{
        std::cout << "我会跑哟\n";
}

void Bird :: move()
{
    std::cout << "我会飞呢\n";
}
 int main()
{
    Animal animal;//不能用类名直接调用函数，要先定义一个对象。
    Bird bird;
    Pig pig;

    animal.move();
    bird.move();
    pig.move();

    return 0;
 }

三、重载方法

#include<iostream>

class Animal
{
public:
          void move();
          void move(int movCount);//重载，移动距离，参数类型或者个数必须不一致
};
void Animal :: move()
{
          std::cout << "我会动哦\n";
}

void Animal :: move(int movCount)
{
          std::cout << "我移动了"<< movCount <<"这么远哦\n";
}

class Pig : Animal
{
public:
        void move();
};

class Bird : Animal
{
public:
        void move();
};

void Pig :: move()
{
        std::cout << "我会跑哟\n";
}

void Bird :: move()
{
    std::cout << "我会飞呢\n";
}
 int main()
{
    Animal animal;//不能用类名直接调用函数，要先定义一个对象。
    Bird bird;
    Pig pig;

    animal.move();
    animal.move(78);

    bird.move();
    //bird.move(1727);当程序如果运行这一句会报错：
    //no matching function for call to'Bird::move(int)'

    pig.move();
    //pig.move(21);

    return 0;
 }

C++中函数重载只能在同一个类中，因为子类中的函数会遮掩住父类中的同名函数。但是使用using 申明式可以使得父类中的同名函数在子类中可见，从而实现函数重载。实现代码如下所示：

#include <iostream>
class Base
{
public:
    void fun(int data)
    {
    std::cout<<"我是int！！！"<<std::endl;
    }
};

class Derivd:public Base
{
public:
    using Base::fun;//这里using申明式可以使得父类中被遮掩住的同名函数在子类中可见，从而在子类中实现函数重载。
    void fun(double data)
    {
    std::cout<<"我是double！！！"<<std::endl;
    }
};

int main()
{
    Derivd d;
    d.fun(1);
    d.fun(1.2);
    return 0;
}

子类调用基类的重载函数

#include <iostream>

class Base
{
public:
    void fun(double data)
    {
        std::cout<<"你好！我是double！"<<std::endl;
    }
    void fun(int data)
    {
    std::cout<<"你好！我是int！"<<std::endl;
    }
};

class Derivd:public Base
{
};

int main()
{
    Base b;
    b.fun(1);
    b.fun(1.2);

    Derivd d;
    d.fun(1);
    d.fun(1.2);

    return 0;
}

关于上上上一个程序所提到的问题，即在子类对基类某函数进行了覆盖的情况下，基类中的重载函数无法被子类调用，好像可以这么解决

#include <iostream>

class Base
{
public:
    void fun(double data)
    {
        std::cout<<"你好！我是double！"<<std::endl;
    }
    void fun()
    {
    std::cout<<"不知道说什么，基类函数里的"<<std::endl;
    }
};

class Derivd:public Base
{
public:
    using Base::fun;
    void fun()
    {
        std::cout<<"哈哈，我是覆盖的哟！"<<std::endl;
    }
};

int main()
{
    Base b;
    b.fun();
    b.fun(1.2);

    Derivd d;
    d.fun();
    d.fun(1.2);

    return 0;
}