Как скрыть из области видимости часть методов базового класса после наследования?

class Parent
{
public:
    void foo() { std::cout << "parent foo " << std::endl; }
    void bar() { std::cout << "parent bar " << std::endl; }
};
 
class Child : public Parent
{
public:
    void fun(int num) { std::cout << "child fun " << std::endl; }
};

Child child;
child.foo();
child.bar();
child.fun();

Child child;
child.foo();
child.Parent::bar();
child.fun();

class A
{
public:
    virtual void func() = 0;
};
 
class B : public A
{    
};
 
template<typename T>
void test(T& obj)
{
    obj.func();
}
 
int main()
{
    B b;
    test(b);
}

struct A
{
    void foo() {}
};
 
struct B: A
{
private:
    using A::foo;
};
 
int main()
{
    B b;
    b.foo(); // fail
    b.A::foo(); // ok
}

class Parent
{
public:
    void foo() { std::cout << "parent foo " << std::endl; }
    void bar() { std::cout << "parent bar " << std::endl; }
};
 
class Child : public Parent
{
    using Parent::bar; // <--- объявляем, что метод Bar
     // в наследнике располагается в приватной секции
public:
    void fun(int num) { std::cout << "child fun " << std::endl; }
};

class Parent
{
public:
    void foo() { std::cout << "parent foo " << std::endl; }
    void bar() { std::cout << "parent bar " << std::endl; }
};
 
class Child
{
public:
    void fun(int num) { std::cout << "child fun " << std::endl; }
    void foo() { m_parent.foo(); }
    void bar() { m_parent.bar(); }
    operator Parent() { return m_parent; }
private:
    Parent m_parent;
};

struct Cat
{
    void Sound();  // умеет мяукать
    void Move();  // умеет двигаться
};
 
struct Dog: protected Cat  //<--- защищенное наследование сообщает компилятору
     // что собака наследует функционал кошки (умения), но при этом кошкой собака не является
{
    void Sound();  // умеет гафкать
 
    // функция член движения Move одинаковая для обоих классов
    // и поэтому собака тупо унаследовала этот функционал
 
    using::Move;
   
};
 
 
void foo(Cat& c)   // <--- принимает кошек
{  ... }
 
 
int main()
{
    Dog d;
    foo(d); // ошибка: приведение возможно, но не доступно
}