Новый шаблон проектирования: Проектное Многоклассовое генерик-наследование

ModuleDrive* dr = new ModuleDrive(); 
ModulePosition pos, pos2;
pos.data0 = 100;
pos2 = dr->MethodGet(pos);
dr->field = pos;

SpecialDrive* dr = new SpecialDrive(); 
SpecialPosition pos, pos2;
pos.data0 = 100;
pos2 = dr->MethodGet(pos);
dr->field = pos;

 
class ModulePosition
{
    __int64 data0;
};
 
 
 
class ModuleDrive
{
    public:
    ModulePosition field; 
 
    ModulePosition  MethodGet(ModulePosition element)
    {
        field.data0 = element.data0; 
        //  + некий код,  нам неважно 
        return  obj;
    }
} ;

 
class SpecialPosition : ModulePosition 
{
    //__int64 data0;   //  <---  унаследуемое от типа ModulePosition 
    int  data1;            //  + добавили что то новое 
};
 
 
 
class SpecialDrive : ModuleDrive
{
    public:
    SpecialPosition field; 
 
    SpecialPosition  MethodGet(SpecialPosition element)
    {
        base.MethodGet ((ModulePosition )element) ;   //  Важный момент.  Это нужно чтобы не дублировать код! 
        //  + добавили что то новое  
        return  obj;
    }
} ;

class ModuleDrive <T>   : T is  ModulePosition  {...}
class SpecialDrive <T>   : T is  SpecialPosition  {...}

    
    SpecialPosition  MethodGet(SpecialPosition element)
    {
        base.MethodGet ((ModulePosition )element) ;   //  Важный момент.  Это нужно чтобы не дублировать код! 
        //  + добавили что то новое  
        return  obj;
    }

template< class Type > class TemplateDrive

typedef TemplateDrive<ModulePosition> ModuleDrive;

class SpecialDrive : TemplateDrive<SpecialPosition>

//-------------ModulePosition  + SpecialPosition--------------------------------------------
 
 
 
 
struct ModulePosition
{
    __int64 data0;
};
 
 
 
struct SpecialPosition : ModulePosition
{
public:
    __int64 data2;
};
 
 
       //  объявлены как структуры, но сути шаблона проектирования это не меняет, аналогично было бы и с class
 
 
//------------------ModuleDrive + SpecialDrive--------------------------------------------
 
 
template< class Type >
class TemplateDrive
{   
public:
    Type field;
    Type MethodGet(Type element);
};
 
 
typedef TemplateDrive<ModulePosition> ModuleDrive;
 
 
 
// далее использование  ModuleDrive - ЭКВИВАЛЕНТНО TemplateDrive<ModulePosition>,  
// а потому класс, использующий именно ModulePosition, мы можем дописать как  ModuleDrive. 
// Попытка использовать с другим типом  TemplateDrive<ДругойТип>  провалится потому что в шаблонном class TemplateDrive - 
// нет реализации метода для всех других типов. По сути, конструкция выше эквивалентна конструкции C# 
// public partial class TemplateDrive<T> where T : ModulePosition
// и даже лучше т.к. в C# нельзя использовать везде без ограничений using ModuleDrive = TemplateDrive<ModulePosition>;  
// так, как в C++  typedef.  (using для этих целей можно использовать только в начале namespace).  
// Необъявление же реализации метода MethodGet - в классе TemplateDrive - так же решается и в C#, только с объявлением  abstract. 
// Поля в ModuleDrive объявляются закомментированными для удобства так же как и в C++, остаётся несущественная разница - 
// т.к. в C++ нет partial слова, то приходится комментировать и сам класс ModuleDrive, оставляя только реализацию методов. 
 
 
 
//class ModuleDrive   //  фактически - реализация класса будет здесь, но из-за отсутствия 'partial' приходится часть - оставлять в одном месте. 
//{
//public:
    //ModulePosition field;    //  Type field;  превращается в ModulePosition, т.к. в typedef объявлен тип 
 
 
    // здесь слово virtual повторно не нужно, т.к.  метод определен внутри класса TemplateDrive, видимо модификаторы virtual можно об-ть только внутри класса.
    // Если этот метод объявить как virtual в классе TemplateDrive тогда придется полностью переписывать код, а так - 
    // можно что то дописать в производных классах,  а часть оставить здесь и попадать сюда, в код базового класса тоже. 
    ModulePosition ModuleDrive::MethodGet(ModulePosition element)      // сигнатура та же, но Type -> превращается в ModulePosition
    {
        element.data0 = 11;   // "Точка1"
        field.data0 = 11;
        return element;
    }
//}    //  class ModuleDrive  
 
 
 
 
// Linker error LNK1120: 1 unresolved externals 
// TemplateDrive<SpecialPosition>* td2 = new TemplateDrive<SpecialPosition>();
// чтобы не было этой ошибки, нужно определить и в этом классе MethodGet, точнее - вызвать базовый 
    SpecialPosition TemplateDrive<SpecialPosition>::MethodGet(SpecialPosition element)      // сигнатура та же, но Type -> превращается в ModulePosition
    {
        //element.data0 = 11;
        //field.data0 = 11;
        //return element;
 
        ModulePosition el =  ((ModuleDrive*)this)->MethodGet((ModulePosition)element);  // "Точка2"
        element.data0 = el.data0;
        return element;
    }
 
 
 
// класс SpecialDrive, в отличие от ModuleDrive уже не объявляется через typedef, а прямо наследуется от TemplateDrive<SpecialPosition>. 
// Поскольку ModuleDrive  в свою очередь, не наследовался в другую ветку, а объявлялся прямо, то 
// 1) TemplateDrive<SpecialPosition>  ------> объект  наследник    от  ModuleDrive  (эквивалентен ему и  TemplateDrive<ModulePosition>)
//     поскольку тип в шаблоне - наследник. (SpecialPosition).  См.. свойство КОВАРИАНТНОСТИ. 
//     Содержит новое только в SpecialPosition внутреннем типе 
// 2) SpecialDrive - наследник от  TemplateDrive<SpecialPosition>, и следовательно от ModuleDrive. (содержит что то свое новое)
//     это значит что если сравнить SpecialDrive и ModuleDrive - то внутри и тип полей которые были ModulePosition- заменится на производные, 
//     и сигнатуры методов использующие этот тип,   и к тому же, сами методы можно переопределить,  + создать новые. 
// МНОГОКЛАССОВОЕ генерик-наследование наследование в этом и состоит. - 
//  Ниже, попадем в  "Точка3"   "Точка2"    "Точка1"  - последовательно, используя SpecialDrive  объект 
 
 
class SpecialDrive : TemplateDrive<SpecialPosition>
{
public:
    //SpecialPosition field;    //  Type field;  здесь превращается в SpecialPosition, т.к. тип объявлен у класса предка 
    int field2;   //  новое поле 
 
 
    // сигнатура та же, но Type -> превращается в SpecialPosition  - компилятор не ругается! 
    SpecialPosition MethodGet(SpecialPosition element) 
    {
        
        //element = TemplateDrive<SpecialPosition>::MethodGet(element); 
        element = ((TemplateDrive<SpecialPosition>*)this)->MethodGet(element);  // "Точка3"
 
        // доопределяем своё
        element.data2 = 22;
        field.data0 = 22;
 
        return element;
    }
};
 
 
 
void   OnBnClickedOk()
{
    
    ModuleDrive md1;
    TemplateDrive<SpecialPosition> td1;
    SpecialDrive sd1;
 
    // выше видно, что от чего наследуется,  ModuleDrive   ->  TemplateDrive<SpecialPosition>   ->  SpecialDrive
    //Watch:
    //в md1 видим что поле field имеет тип  ModulePosition
    //в td1 видим что поле field имеет тип  SpecialPosition
    //в sd1 - еще появилось поле field2
 
 
 
 
    ModuleDrive* m1 = new ModuleDrive(); 
    ModulePosition posM;
    posM.data0 = 100;
    m1->MethodGet(posM);   // 
 
 
    //  ЭКВИВАЛЕНТНЫЙ КОД, с использованием  производного целого ПРОЕКТА 
    
    SpecialDrive* m3 = new SpecialDrive();
    SpecialPosition posS;
    posS.data0 = 100;
    m3->MethodGet(posS);   //  Здесь, попадем в  "Точка3"   "Точка2"    "Точка1"  - последовательно, используя SpecialDrive  объект 
 
 
    // таким образом SpecialDrive НЕЯВНО унаследован от ModuleDrive,  одновременно с внутренними полями и сигнатурами методов, 
    // у SpecialDrive  внутри везде используется SpecialPosition,  а у ModuleDrive  - используется ModulePosition.  
 
    // Получается многоклассвое наследование.  Если далее создать еще пару классов,  к примеру 
    // ModuleController  и   SpecialController (3-й уровень),  второй так же неявно унаследовать от первого, а внутренние классы у них будут 
    // использоваться, вышеописанные  ModuleDrive и SpecialDrive (2-й уровень)  соответственно, то получим уже связное множество из 3-х классов, 
    // унаследованное от связного множества из  3-х классов. 
    // Продолжая по аналогии,  можно создать целый проект из N классов, который можно использовать как базовый для 
    // другого проекта, из унаследованных этих N классов. 
    
 
}
    
//----------------------------------------------------------------------------------------------------

//--------------- {1}  PROJECT ModuleProject  -------------------------------------------------> 
 
 
class ModulePosition
{
    public: int data1 = 5;  // 5 - по умолчанию
    // для простоты - только один int, а вообще могут быть любые сложные данные. 
};
 
 
//  "Хитрая конструкция".  Зачем нужна -  описание ниже.
template< class Type >
class TemplateDrive
{
    protected:
 
    Type field1;
    Type field2;
    Type field3;
    Type field4;
    Type field5;   // для простоты, создадим 5 элементов, а вообще может быть список и т.д. что угодно - сложнее  
 
    public:
    void MethodSet(int seed);
    int MethodCalculate(Type element);
};
typedef TemplateDrive<ModulePosition> ModuleDrive;
// Конец "Хитрой конструкции". 
 
 
 
// в С++  нет ключевого слова 'partial', потому объявление класса ниже, ModuleDrive - закомментировано. Но по сути, это программистом воспринимается как 
// полноценно описанный класс, ModuleDrive - который НЕ УНАСЛЕДОВАН от шаблонного класса выше, 
// а именно - ЭКВИВАЛЕНТЕН ему (потому выше и использовали typedef и "Хитрую конструкцию" выше). 
// Итак, всё что есть в этом классе - или имплементировано, или закомментировано (но оно тоже ПРИСУТСТВУЕТ) -- 
 
 
//-------------------
//class ModuleDrive
//{
// protected:
  
// ModulePosition field1;
// ModulePosition field2;
// ModulePosition field3;
// ModulePosition field4;
// ModulePosition field5;  // все  поля  компилятор превратит здесь в   ModulePosition, 
 
//  public:
 
void ModuleDrive::MethodSet(int seed)
{
    // "Точка 1a"
    field1.data1 = 1 + seed;
    //  тут может быть любая сложная логика, но для простоты, написали некую простую реализацию в зависимости от параметра seed
}
 
 
int ModuleDrive::MethodCalculate(ModulePosition element)  // сигнатура похожая, но параметр Type -> превращается в ModulePosition. Всё обеспечивает "Хитрая конструкция" выше. 
{
    // "Точка 1b"
    int sum = 0;
    sum += field1.data1;
 
    return (sum * element.data1);
}
//}    //  class ModuleDrive    //  конец описания класса. И заодно, проекта ModuleProject.   Он простой, всего из двух классов. 
//-------------------
 
 
 
 
 
 
 
//--------------- {2} внешний код, использующий  PROJECT ModuleProject  ---------------------------------------> 
 
 
//  по сути, здесь эквивалент обращения только к методам интерфейсов. Ну, у ModulePosition поле data1 объявлено для простоты, 
// публичным.  Можно и его спрятать, и обращаться к нему через методы - суть от этого не изменится. 
 
/*
ModulePosition elem;
ModuleDrive* dr = new ModuleDrive();
dr->MethodSet(10);
int result = dr->MethodCalculate(elem);
*/
 
 
 
 
 
//--------------- {3}  внешний код, использующий будущий наследуемый PROJECT SpecialProject  -------------------------------------------------> 
 
// теперь нам нужно унаследовать цельный проект из N связных классов - другим проектом из N связных классов. 
// Многоклассовое генерик-наследование . Как будто, целое связное множество классов, наследуется от другого связного множества
// (псевдокод) -
// InheritSet{ InheritClass1, InheritClass2, InheritClass3 ... } : BaseSet{ BaseClass1, BaseClass2, BaseClass3 ... }
// и здесь наследование именно такое, что в Тьюринг-полном языке, любой код можно по аналогии, превратить
// в рабочий код с другим проектом, просто заменив все названия из первого множества - их прототипами
// из второго множества.
 
// Выше, в проекте ModuleProject использовалось для простоты только два класса, значит их и унаследуем. Т.е. 
// SpecialSet{ SpecialPosition, SpecialDrive ... } : ModuleSet{ ModulePosition, ModuleDrive ... }
// Внешний код должен быть только таким, и никаким другим !!!!! 
 
// !!!!!!!!!!!! 
/*
SpecialPosition elem;
SpecialDrive* dr = new SpecialDrive();
dr->MethodSet(10);
int result = dr->MethodCalculate(elem);
*/
 
// Никаких других, громоздких TemplateDrive<SpecialPosition>  или еще чего то - во внешнем коде быть НЕ ДОЛЖНО. 
// ООП -  изобретали, только потому чтобы люди могли написать более сложные проекты, а ЕСЛИ БЫ НЕ ЭТО 
// (и были бы вопросы типа - "а зачем это всё". можно же и без этого обойтись) - то в принципе достаточно было бы 
// ограничиться старым-добрым "Процедурным программированием". В плане теоретически-возможной функциональности - вполне достаточно. 
// Так и здесь - мы придерживаемся строгих наименований, потому что  - 
// в плане "Очень сложных проектов", включающих в себя 100 библиотек, с разными зависимостями между собой, подобный подход может 
// оказаться очень продуктивным и хорошим. после написания новой библиотеки, максимум что можно изменить во внешнем коде -  ОДНО СЛОВО в нём,
// В данном случае - заменили Module  на  Special - как базовое слово в названии библиотеки. 
// Итак, цель выше поставлена - именно такой внешний код, должен работать. 
 
 
 
 
//--------------- {4}  PROJECT SpecialProject  -------------------------------------------------> 
 
 
 
class SpecialPosition : public ModulePosition
{
public:
    //  int data1;   //  это поле, унаследовалось от ModulePosition
    int dataNew = 15;       //  + добавили что-то новое    (15 - по умолчанию)
};
 
 
 
 
class SpecialDrive : public TemplateDrive<SpecialPosition> // : ModuleDrive  (т.е. далее не пишем, но знаем, что в конечном итоге унаследуется от ModuleDrive ) 
{
    private:
 
    //  и 1++++ не надо создавать новые поля, явно указанные типом SpecialPosition, и впустую тратить память на данное поле - благодаря применению Генерик-классов!  
    // SpecialPosition field1;
    // SpecialPosition field2;
    // SpecialPosition field3;
    // SpecialPosition field4;
    // SpecialPosition field5;    //   унаследуемые поля  компилятор превратит здесь в   SpecialPosition, 
                
    int fieldNew;   // + добавили что то  новое  
 
 
    public:
 
    void MethodSet(int seed)
    {
        //  и  3++++ дублирования кода нет, благодаря наследованию. (если бы применили только Генерик классы, без наследования, то код пришлось бы определить в 2-х местах). 
        // аналог  шарповского  base.MethodSet(seed);
        ((ModuleDrive*)this)->MethodSet(seed);   // "Точка 2a"  --> попадем внутрь к точке 1a 
            
 
        // доопределяем новое 
        //  и  2++++ не надо делать явное преобразование типов каждый раз так ((SpecialPosition)field1).dataNew - благодаря применению Генерик-классов!  
        field1.dataNew = 1 + (seed * 2);
        field2.dataNew = 2 + (seed * 2);
        field3.dataNew = 3 + (seed * 2);
        field4.dataNew = 4 + (seed * 2);
        field5.dataNew = 5 + (seed * 2);
    }
 
 
    
    // сигнатура похожая, но   параметр ModulePosition -> превращается в SpecialPosition  
    int MethodCalculate(SpecialPosition element)
    {
        //  и  3++++ дублирования кода нет, благодаря наследованию. (если бы применили только Генерик классы, без наследования, то код пришлось бы определить в 2-х местах). 
        // аналог  шарповского  base.MethodCalculate(seed);
        int sum = ((ModuleDrive*)this)->MethodCalculate(element);   // "Точка 2b"  --> попадем внутрь к точке 1b 
 
        // + доопределяем новое 
        
        int sum2 = 0;
        sum2 += field1.dataNew;
        sum2 += field2.dataNew;
        sum2 += field3.dataNew;
        return (20* sum / sum2  + element.data1);
        
        return sum;
    }
    
};
 
 
 
//--------------- {5} ВЫВОДЫ   -------------------------------------------------> 
/*
Выше описаны два проекта, ModuleProject  и  SpecialProject ,  которые построены таким образом, что 
a) классы в них используют шаблоны (генерик-паттерн), 
b) и вместе с тем, классы второго проекта, наследуют классы первого проекта. 
 
c) внешний код который должен работать с первым проектом - 
 
ModulePosition elem;
ModuleDrive* dr = new ModuleDrive();
dr->MethodSet(10);
int result = dr->MethodCalculate(elem);
 
d) внешний код который должен работать с вторым проектом - 
 
SpecialPosition elem;
SpecialDrive* dr = new SpecialDrive();
dr->MethodSet(10);
int result = dr->MethodCalculate(elem);
 
 
 
!!!  
При попытке перевести этот  код   на C++,  на  C#,  вы столкнетесь с одной из следующих  4-х ПРОБЛЕМ.  (которые данный паттерн и решает). 
  
1) //  и 1++++ не надо создавать новые поля, явно указанные типом SpecialPosition, и впустую тратить память на данное поле - благодаря применению Генерик-классов!  
-- это строка выше из приведенного кода.  Если не применять генерики, то ПРИДЕТСЯ создать доп. поля и заполнить оперативную памяять ненужной информацией, 
что может быть критично в проектах алгоритмического характера. Проблема НОМЕР№ 1. 
 
 
2) //  и  2++++ не надо делать явное преобразование типов каждый раз так ((SpecialPosition)field1).dataNew - благодаря применению Генерик-классов!  
-- это строка выше из приведенного кода.  Если не применять генерики, то в коде будут лишние доп. затраты процессора на явное преобразование типов, 
что может быть критично в проектах алгоритмического характера. (если там будут миллиарды операций). Проблема НОМЕР№ 2. 
 
 
3) //  и  3++++ дублирования кода нет, благодаря наследованию. (если бы применили только Генерик классы, без наследования, то код пришлось бы определить в 2-х местах). 
-- это строка выше из приведенного кода.  Деюлирование кода - это ВСЕГДА плохо. В случае изменений, нужно его менять в нескольких местах.  Проблема НОМЕР№ 3. 
 
 
4) В C# этого typedef  нет, непонятно зачем убрали, но есть возможность использовать using , как то типа - 
using DWORD = System.UInt64;
или
using ModuleDrive = TemplateDrive<T> : T  is  ModulePosition;
--
Этот using - нам придётся вставлять в каждый файл с исходным кодом!
А если файлов много, + самих переопределяемых классов будет много - будет замусоривание кода.  Проблема НОМЕР№ 4. 
На C++ же, в оном месте объявил  typedef , как эквивалентный тип, и всё. 
 
Вот, решить все выше приведенные проблемы - НОМЕР№ 1, 2,3,4  --  данный паттерн, с использованием  typedef и позволяет. 
 
 
*/