Теоретическая C++ OO код Стратегия

Question

Допустим, у меня есть кусок кода:

A1 a; 
A2 b; 
a= function1_A(); 
b= function2_A(); 

А потом я хочу сделать это по-другому:

B1 a; 
B2 b; 
a= function1_B(); 
b= function2_B(); 

И я делаю шаблон стратегии дизайна для оба и решить, какой я хочу. Но дело в том, что код тот же, что и для всех A, теперь B. Конечно, то, что это делает, может быть совершенно другим, но это выходит за рамки.

Есть ли способ разработать код, чтобы предотвратить такое повторение?

Если бы это было просто функции я знаю, что я мог бы сделать это с абстрактным суперкласса и он

a=function1_SUPER(); 

, а затем каждый имеет правильное применение, как:

function1_SUPER(){ function1_A();} 

но по-прежнему генерирует много кода. Плюс не работает с именами классов, например, с изменением A1-B1?

Answer 1

Я хотел бы составить проблему в двух частях я вижу: во-первых, distiguishing по типу (A1, A2 по сравнению с B1, B2) и во-вторых, различие по инициализации переменных. Поскольку вы говорите, код все-таки, но типы не шаблоны приходят на ум. Так что моя первая попытка была бы:

template <class X1, class X2> 
struct MyStrategy { 
    void foo() 
    { 
    X1 a = /* create appropiate X1 */; 
    X2 b = /* create appropiate X2 */; 
    // code that is the same for both except for the types... 
    } 
}; 

Конечно функция будет иметь параметры и/или тип возвращаемого значения, но вы получите суть.

Теперь во вторую часть, которую я оставил в комментариях: инициализация значений. Я бы достиг этого, используя какой-то политический дизайн. Первый эскиз:

template <class X1, class X2> 
struct X1X2Creator; 

template <> 
struct X1X2Creator<A1, A2> { 
    A1 createX1() { return function1_A(); } 
    A2 createX2() { return function2_A(); } 
}; 

template <> 
struct X1X2Creator<B1, B2> { 
    B1 createX1() { return function1_B(); } 
    B2 createX2() { return function2_B(); } 
}; 


template <class X1, class X2> 
struct MyStrategy : X1X2Creator<X1, X2> { 
    void foo() 
    { 
    X1 a = this->createX1(); 
    X2 b = this->createX2(); 
    // code that is the same for both except for the types... 
    } 
}; 

Примечание Вы должны вызвать создания-функций с помощью this->createX1(), из-за их зависимых имен, в противном случае компилятор должен жаловаться. Вы также можете четко определить функции (X1X2Creator<X1, X2>::createX1()).

Вы можете улучшить этот дизайн по вашим потребностям, например. не используя наследование, а создавая экземпляр X1X2Creator и вызывая функции или ставя их. Если вы хотите использовать больше комбинаций различных типов, использовать одну политику создания по типу:

template <class X1, class X2> 
struct MyStrategy { 
    void foo() 
    { 
    X1 a = CreationPolicy<X1>::create(); 
    X2 b = CreationPolicy<X2>::create(); 
    // code that is the same for both except for the types... 
    } 
}; 

Если вы хотите, чтобы иметь возможность использовать различные политики для одних и тех же типов, обеспечивают классы Policie в качестве параметров шаблона:

template <class X1, class X2, 
    class X1Creator = CreationPolicy<X1>, 
    class X2Creator = CreationPolicy<X2>> 
struct MyStrategy { 
    void foo() 
    { 
    X1 a = X1Creator::create(); 
    X2 b = X2Creator::create(); 
    // code that is the same for both except for the types... 
    } 
}; 

HTH

Answer 2

Я думаю, вы должны использовать шаблон. Например:

#include <iostream> 

template <class C1, class C2> class MyClass 
{ 
public: 
    C1 *function1() 
    { 
     return new C1(); 
    }; 

    C2 *function2() 
    { 
     return new C2(); 
    }; 
}; 

int main() 
{ 
    MyClass<int, double> intDoubleClass; 

    int *a1 = intDoubleClass.function1(); 
    double *a2 = intDoubleClass.function2(); 

    return 0; 
}