class A
{
public:
    void func()
    {
        cout << "A\n";
    }
};

class B : public A
{
public:
    bool func()         // ИСПРАВЛЕНИЕ №1. Если заменить на void func(), то все нормально
    {
        cout << "B\n";
        return true;
    }

    void ssss()
    {
        B::func();    // С2668
    }

protected:
    using A::func;      // ИСПРАВЛЕНИЕ №2. Закаментировать и все заработает 
};

B b;
bool value = b.f();

Л>class A
Л>{
Л>public:
Л>    void func()
Л>    {
Л>        cout << "A\n";
Л>    }
Л>};

Л>class B : public A
Л>{
Л>public:
Л>    bool func()         // ИСПРАВЛЕНИЕ №1. Если заменить на void func(), то все нормально

Л>protected:
Л>    using A::func;      // ИСПРАВЛЕНИЕ №2. Закаментировать и все заработает 
Л>};
Л>

— Function declarations that differ only in the return type cannot be overloaded.

A function member of a derived class is not in the same
scope as a function member of the same name in a base class. [Example:
class B {
public:
int f(int);
};
class D : public B {
public:
int f(char*);
};
Here D::f(char*) hides B::f(int) rather than overloading it.

КЛ>>B b;
КЛ>>bool value = b.f();
КЛ>>

//Листинг 9.6. Наследование от абстрактного класса
class Food                          // абстрактный класс "Пища животного"
{ public: 
    virtual string typeFood() const = 0;        // тип пищи
};
class Animal                        // абстрактный класс "Животное"
{ public: 
    virtual string kind() const = 0;            // вид животного
    virtual Food& eats() = 0;                   // что ест
};
class Tiger: public Animal          // Тигр – конкретный вид животного
{ public: 
    virtual string kind() const                 // идентификация вида
    { return "Tiger"; }
    class TigerFood: public Food                // пища тигра
    { public: 
        virtual string typeFood() const         // идентификация пищи тигра
        { return "Tiger food"; }
    };
    virtual TigerFood& eats()                   // ест пищу тигра
    {  return tiger; }
  private:
    TigerFood tiger;                            // объект – пища тигра
};
class Dog: public Animal            // Собака – конкретный вид животного
{ public: 
    virtual string kind() const                 // идентификация вида
    { return "Dog"; }
    class DogFood: public Food                  // пища собаки
    { public: 
        virtual string typeFood() const         // идентификация пищи собаки
        { return "Dog food"; }
    };
    virtual DogFood& eats()                     // ест пищу собаки
    {  return dog; 
    }
  private:
    DogFood dog;                                // объект – пища собаки
};
int main()
{ Tiger t; Dog d;                               // объекты-животные
  Animal& pt = t; Animal& pd = d;               // подстановка ссылок
  Animal *p[] = { &t, &d };                     // подстановка указателей
// виртуальный вызов по ссылке
  cout << pt.eats().typeFood() << endl;
  cout << pd.eats().typeFood() << endl;
// виртуальный вызов по указателю
  cout << p[0]->eats().typeFood() << endl;
  cout << p[1]->eats().typeFood() << endl;
// присвоение измененного типа
  Tiger::TigerFood tf = t.eats();
  Dog::DogFood df = d.eats();
 return 0;
}

Сначала определены два абстрактных базовых класса Food и Animal. Эти классы определяют для своих наследников минимальные общие интерфейсы (чистые виртуальные функции). Класс Tiger, наследуя от Animal, содержит вложенный класс TigerFood — наследника от Food. Класс TigerFood вложен в Tiger, так как эти классы тесно связаны — тигр есть только свою пищу. Впрочем, исходный абстрактный базовый класс Food можно вложить и в исходный абстрактный класс Animal:

class Animal
{ public: 
    class Food                // вложенный абстрактный класс
    { public: 
        virtual string typeFood() const = 0;
    };
    virtual string kind() const = 0;
    virtual Food& eats() = 0;
};

Тогда вложенный класс TigerFood будет наследником от вложенного абстрактного класса Food.
Метод eats(), который в базовом классе Animal возвращал ссылку на базовый класс Food, переопределен и возвращает ссылку на TigerFood — изменено возвращаемое значение. Аналогично можно изменять и тип возвращаемого указателя.
Точно такое строение имеет и класс Dog. Главная программа демонстрирует правильные вызовы виртуальных функций eats() через ссылки и указатели базового типа.

7.3.3/12
When a using-declaration brings names from a base class into a derived class scope, member functions in
the derived class override and/or hide member functions with the same name and parameter types in a base
class (rather than conflicting).

КЛ>>>B b;
КЛ>>>bool value = b.f();
КЛ>>>

// declarations
class A;
class B;// эти два класса не связаны наследованием
A f(int,float);
B f(float,int);

// using
A a=f(1,1);

Л>class A
Л>{
Л>public:
Л>    void func()
Л>    {
Л>        cout << "A\n";
Л>    }
Л>};

Л>class B : public A
Л>{
Л>public:
Л>    bool func()         // ИСПРАВЛЕНИЕ №1. Если заменить на void func(), то все нормально
Л>    {
Л>        cout << "B\n";
Л>        return true;
Л>    }

Л>    void ssss()
Л>    {
Л>        B::func();    // С2668
Л>    }

Л>protected:
Л>    using A::func;      // ИСПРАВЛЕНИЕ №2. Закаментировать и все заработает 
Л>};
Л>

bool A::func()
bool B::func() //но объект производного класса является объектом базового!!

bool A::func(int){//your code
}