В C++ метод производного класса всегда переопределяет метод базового класса?

#pragma once
 
#include <iostream>
 
using namespace std;
 
class Fish
{
public:
    virtual ~Fish() = default;
 
    Fish(bool isFreshWater) : isFreshWaterFish(isFreshWater) { }
 
    virtual void Swim(bool isFreshWater)
    {
        if (isFreshWater)
            cout << "Swims in lake. "  << endl;
        else
            cout << "Swims in sea" << endl;
    }
 
    virtual void Swim()
    {
        if (isFreshWaterFish)
            cout << "Swims in lake" << endl;
        else
            cout << "Swims in sea" << endl;
    }
 
private:
    bool isFreshWaterFish;
};
 
class Tuna : public Fish
{
public:
    // Раскрытие скрытых текущей реализацией методов Swim базового класса
    using Fish::Swim;
 
    Tuna() : Fish(false) 
    {
        cout << "Tuna swims real fast" << endl;
    }
 
    void Swim() override
    {
        cout << "Tuna swims real fast" << endl;
    }
};
 
class Carp : public Fish
{
public:
    Carp() : Fish(true) { }
 
    // В С++ нет такого понятия, как сокрытие метода базового класса, но и одновременно 
    // и не его переопределение. Если в C# можно скрыть метод, но не переопределить, то в 
    // С++ метод автоматом считается переопределяемым.
    void Swim()
    {
        cout << "Carp swims real slow" << endl;
    }
};

Carp carp;
carp.Fish::Swim(); // принудительно выполнить метод родительского класса Fish

Carp carp;
Fish &fish = carp;
fish.Swim();  // вызовется Carp::Swim(), несмотря на то, что ссылка имеет тип Fish

Fish *p_fish = new Carp;
delete p_fish;

Fish *p_fish = new Carp;
delete static_cast<Carp *>(p_fish);

#include <iostream>
 
class Base{
public:
    virtual ~Base(){std::cout<<"Base\n";}
};
 
struct Checker{
    ~Checker(){std::cout<<"Checker\n";}
};
 
class Inherited: public Base{
    Checker bb;
public:
    ~Inherited(){std::cout<<"Inherited\n";}
};
 
int main()
{
    Base* b = new Inherited();
    delete b;
}

#include <iostream>
 
using namespace std;
struct Base
{
    virtual void foo(){cout<<"\nbase\n";}
    virtual void nobro(){cout<<"\nnobro\n";}
 
};
 
struct ChildDefault : public Base
{
    void foo(int){cout<<"\nchild non-virtual\n";}
 
 
};
 
int main()
{
ChildDefault chd;
Base * bs(&chd);
bs->foo();
//chd.foo();//нету -раскомментируйте и получите ошибку
chd.nobro();//тут нормально
    return 0;
}

#include <iostream>
 
using namespace std;
 
struct Base
{
    virtual void foo() { cout << "\nbase\n"; }
    virtual void nobro() { cout << "\nnobro\n"; }
};
 
struct ChildDefault : public Base
{
    using Base::foo;
 
    void foo(int) { cout << "\nchild non-virtual\n"; }
};
 
int main()
{
    ChildDefault chd;
    Base* bs(&chd);
    bs->foo();
    chd.foo();     // Заработало благодаря using Base::foo;
    chd.nobro();
    return 0;
}