DS>Коллеги, прошу простить мое невежество! Просвятите! Чем отличаются "чисто виртуальные" и "абстрактные" классы (про "чисто абстрактные" слышу впервые; "чисто" — наверное жаргон ). Неужели абстрактные — это те, у которых ВСЕ методы чисто витруальные?

class a {
public:
  virtual void f() = 0;
};

DS>>Коллеги, прошу простить мое невежество! Просвятите! Чем отличаются "чисто виртуальные" и "абстрактные" классы (про "чисто абстрактные" слышу впервые; "чисто" — наверное жаргон ). Неужели абстрактные — это те, у которых ВСЕ методы чисто витруальные?

IT> Абстрактные — это у которых ХОТЯ БЫ ОДИН метод не имеет реализации.

IT>class a {
IT>public:
IT>  virtual void f() = 0;
IT>};
IT>

class a {
public:
  virtual void f() = 0
    { ... }
};

#include <iostream>
#include <vector>

using namespace std;

struct IRun
{
    virtual void Run() = 0;
};

struct ISetup
{
    virtual void Setup() = 0;
};

struct ITest : public IRun, public ISetup
{
};

class CTest : public ITest
{
public:
    CTest() {}
    virtual ~CTest() {}
    virtual void Setup() {}
    virtual void Run() { cout << "CTest::Run()" << endl; }
};

int main()
{
    vector <ITest *> data;
    for(int i=0; i<3; i++)
        data.push_back(new CTest);

    ITest &ref = *data.front();
    ref.Run();

    for(vector <ITest *>::iterator it = data.begin(); it != data.end(); ++it)
            delete (*it);

    data.clear();
    
    return 0;
}

class CA
{
public:
    CA() : m_nA(0) { }
    CA(int nA) : m_nA(nA) { }

protected:
    int m_nA;
};

class CB : virtual public CA
{
public:
    CB(int nB) : CA(nB), m_nB(nB) { } 

protected:
    int m_nB;
};

class CC : public CB
{
public:
    CC() : CB(1), m_nC(1) { }
    CC(int nC) : CB(nC), CA(nC), m_nC(nC) { }

protected:
    int m_nC;
};

CC с0;
CC с1(1);

c0 = {m_nA = 0, m_nB = 1, m_nC = 1 } // а не {m_nA = 1, m_nB = 1, m_nC = 1 } как может показаться
c1 = {m_nA = 1, m_nB = 1, m_nC = 1 }

S>Может не поверишь, Игорь, но иногда небольшой смысл есть . С virtual наследованием (хотя эта вещь закладывалась как раз для полиморфного наследования) можно делать вот такую вещь

class CA
{
public:
//    CA() : m_nA(0) { }
    CA(int nA) : m_nA(nA) { }
};