Hello!
Зашёл спор, есть люди которые утверждают что бывает такая ошибка.(видел один раз такой мессадж в Нейро Бёрнинг)
Как она может появится если компилятор таки случаи отслеживает.
В часности:

class A
{
    virtual int Foo(int i)=0;
};

class B: public A
{
    virtual int S(int d)
    {
        return 1;
    }
};

пример вызвает ошибку:

error C2259: 'B' : cannot instantiate abstract class
due to following members:
'int A::Foo(int)' : pure virtual function was not defined

Здравствуйте, 1234, Вы писали:

1>Hello!
1>Зашёл спор, есть люди которые утверждают что бывает такая ошибка.(видел один раз такой мессадж в Нейро Бёрнинг)
1>Как она может появится если компилятор таки случаи отслеживает.

Можно опосредованно вызвать виртуальный метод из конструктора/деструктора

struct A
{
  virtual void foo() = 0;
  virtual void bar() = 0;

  void call_foo() { foo(); } // вызов виртуального метода
  void call_bar() { bar(); }

  A() // в этот момент vfptr указывает на VMT класса A, с абстрактными методами
  {
    foo(); // статический вызов
    bar(); // статический вызов --> ошибка линкера
    call_foo(); // бабах!
    call_bar(); // бабах!
  }
};

void A::foo() {}
// абстрактные методы можно определять

struct B : A
{
  void foo() {}
  void bar() {}

  B() // бабах в конструкторе A
  {
    foo(); // статический вызов
    call_foo(); // метод уже не абстрактный
  }
};

main()
{
  A a; // ошибка компилятора: абстрактный класс
  B b;
}

Здравствуйте, Кодт, Вы писали:

К>Здравствуйте, 1234, Вы писали:

1>>Hello!
1>>Зашёл спор, есть люди которые утверждают что бывает такая ошибка.(видел один раз такой мессадж в Нейро Бёрнинг)
1>>Как она может появится если компилятор таки случаи отслеживает.

К>Можно опосредованно вызвать виртуальный метод из конструктора/деструктора
К>

К>struct A
К>{
К>  virtual void foo() = 0;
К>  virtual void bar() = 0;

К>  void call_foo() { foo(); } // вызов виртуального метода
К>  void call_bar() { bar(); }

К>  A() // в этот момент vfptr указывает на VMT класса A, с абстрактными методами
К>  {
К>    foo(); // статический вызов
К>    bar(); // статический вызов --> ошибка линкера
К>    call_foo(); // бабах!
К>    call_bar(); // бабах!
К>  }
К>};

К>void A::foo() {}
К>// абстрактные методы можно определять

К>struct B : A
К>{
К>  void foo() {}
К>  void bar() {}

К>  B() // бабах в конструкторе A
К>  {
К>    foo(); // статический вызов
К>    call_foo(); // метод уже не абстрактный
К>  }
К>};

К>main()
К>{
К>  A a; // ошибка компилятора: абстрактный класс
К>  B b;
К>}
К>

Действеитльно...