Хотелось бы узнать мнение об такой структуре кода:

class A
{
int x;
int y;
public:
    virtual void funcRun( void );
protected:
    void Run ( void )
        {
            x = x+y;
        };
};

class B : A
{
public:
    B()
    {
        x = 1;
        y = 2;
    };
    void funcRun ( void )
    {
        Run();
    };
};

class C : A
{
public:
    C()
    {
        x = 3;
        y = 4;
    };
    void funcRun ( void )
    {
        Run();
    };
};


void testFunc(A *a)
{
    a->funcRun();
}

int main()
{
B b;
C c;
testFunc(b);
testFunc(c);
return 0;
}

Можно ли назвать ее адекватной с точки зрения рефакторинга и какие проблемы подобная структура может повлечь?

S>Хотелось бы узнать мнение об такой структуре кода:
Непонятно, зачем она такая понадобилась. Зачем нужна виртуальная функция, которая одинаково определена во всех производных классах? Зачем двойной вызов? (Run->funcRun)?

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

S>Можно ли назвать ее адекватной с точки зрения рефакторинга и какие проблемы подобная структура может повлечь?
код адекватный, т.к. код, который не компилируется, очень легко рефакторить, чтобы сохранить некомпилябельность

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

S>Хотелось бы узнать мнение об такой структуре кода:

S>Можно ли назвать ее адекватной с точки зрения рефакторинга и какие проблемы подобная структура может повлечь?

Помимо того, что код не рабочий, так и пример крайне неудачный, чтобы думать про структуру.

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

S>>Хотелось бы узнать мнение об такой структуре кода:
V>Непонятно, зачем она такая понадобилась. Зачем нужна виртуальная функция, которая одинаково определена во всех производных классах? Зачем двойной вызов? (Run->funcRun)?

Такую структуру я использую в наборе тестов для класса. Поскольку смысл тестов это конфигурирование определенного элемента и вызов однотипных функций решил реализовать с использованием виртуального класса. Функция Run подготавливает данные. У меня маленький опыт программирования поэтому хотелось бы совета, как это сделать лучше?

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

S>Хотелось бы узнать мнение об такой структуре кода:
S>...
S>Можно ли назвать ее адекватной с точки зрения рефакторинга и какие проблемы подобная структура может повлечь?

Во-первых, инициализацию базы, лучше выполнять не через прямой доступ к ее членам, а через конструктор;

А во-вторых, не совсем понятно, какой смысл ты вкладываешь в термин "структура кода" и адекватной чему она должна быть. Тебя интересует, нормально ли то, что из переопределенных виртуальных функций выполняется обращение к функциям базового класса? Ну само по себе это не криминал — если это обосновано, то и оправдано. Только в конкретном примере, который ты привел, обоснований этому не видно. Совершенно не понятно, почему бы производным классам в твоем примере просто не унаследовать реализацию базового:

class A
{
public:

  A(int x, int y) : x(x), y(y) { }

  virtual void funcRun() { x += y; }
private:
  int x;
  int y;
};

class B : public A
{
public:
  B() : A(1, 2) { }
};

class C : public A
{
public:
  C() : A(3, 4) { }
};

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

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

S>>Хотелось бы узнать мнение об такой структуре кода:
S>>...
S>>Можно ли назвать ее адекватной с точки зрения рефакторинга и какие проблемы подобная структура может повлечь?

R>Во-первых, инициализацию базы, лучше выполнять не через прямой доступ к ее членам, а через конструктор;

R>А во-вторых, не совсем понятно, какой смысл ты вкладываешь в термин "структура кода" и адекватной чему она должна быть. Тебя интересует, нормально ли то, что из переопределенных виртуальных функций выполняется обращение к функциям базового класса? Ну само по себе это не криминал — если это обосновано, то и оправдано. Только в конкретном примере, который ты привел, обоснований этому не видно. Совершенно не понятно, почему бы производным классам в твоем примере просто не унаследовать реализацию базового:

R>

R>class A
R>{
R>public:

R>  A(int x, int y) : x(x), y(y) { }

R>  virtual void funcRun() { x += y; }
R>private:
R>  int x;
R>  int y;
R>};

R>class B : public A
R>{
R>public:
R>  B() : A(1, 2) { }
R>};

R>class C : public A
R>{
R>public:
R>  C() : A(3, 4) { }
R>};
R>

Спасибо сделаю так как вы описали. Думаю так действительно будет более правильнее. Вообще вся эта затея была для написания тестов к классу и как это лучше сделать за неимением опыта не знал.

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

S>Спасибо сделаю так как вы описали. Думаю так действительно будет более правильнее. Вообще вся эта затея была для написания тестов к классу и как это лучше сделать за неимением опыта не знал.

За что спасибо, я ведь не дал каких-либо рекомендаций Я ведь не имел ввиду, что делать нужно именно так, как я показал. Основной моей мыслью было, что по приведенному тобой примеру трудно понять, чего именно ты хочешь добиться. Думаю, если ты сформулируешь задачу более конкретно (но при этом внятно и, желательно, лаконично), то тебе наверняка дадут дельный совет.