Сложность абстракции, полиморфизм, дублирование и другие

//структура "матрица"
//Представляет собой обёртку над двухмерным массивом
template<typename TypeT, int _SizeX, int _sizeY>
struct Array2D
{
    Array2D()
    {
        for(int y = 0; y < _sizeY; ++y)
        {
            for(int x = 0; x < _SizeX; ++x)
            {
               Arr[x][y] =  rand()%100 + 1;
            }
        }
    }
    TypeT Arr[_SizeX][_sizeY];
};
 
//создаём 100 штук таких матриц
//каждая матрица будит проинициализирована
//случайными числами
Array2D<int,100,100> SuperArray[100];
 
 
int main()
{
   return 0;
};

struct A { int a;};
struct B { int a;};  //одна из них явно лишьняя
 
 
class Base
{
public:
    Base(){}
    virtual ~Base(){};
    virtual void View()=0;
};
 
class ConcreteA: public Base
{
public:
                     ConcreteA():Base(){}
    /*virtual */    ~ConcreteA() {}
    /*virtual*/      void View() { std::cout<< "ConcreteA\n";}
};
 
class ConcreteB: public Base
{
public:
                    ConcreteB():Base(){}
    /*virtual */    ~ConcreteB() {}
    /*virtual*/     void View() { std::cout<< "ConcreteB\n";}
};
 
//Самый популярный рецепт изготовления полиморфного семейства:
//1. Написать базовый интерфейс.
//2. Хардкорно копипастить его по всем потомкам.
 
//Причем зачастую, полиморф пользуют везде, где хотят 
//программировать в терминах интерфейсов. 
//даже там, где не требуется воспринимать абсолютно 
//разные типы объектов, как одну и туже сущность.

class Base
{
public:
   virtual void Foo()
   {
       std::cout << "Base" << std::endl;
   }
   virtual ~Base()
   {
   }
};
 
class Der1 : public Base
{
public:
   virtual void Foo()
   {
       std::cout << "Der1" << std::endl;
   }
   virtual ~Der1()
   {
   }
};
 
class Der2 : public Base
{
public:
   virtual ~Der2()
   {
   }
};

#include <memory>
#include <iostream>
 
class Base {
public:
   virtual ~Base() = 0;
 
   virtual void foo() {
      std::cout << "base foo " << std::endl;
   }
   
   virtual void bar() {
      std::cout << "base bar " << std::endl;
   }
   
   virtual void quz() {
      std::cout << "base quz " << std::endl;
   }
};
 
Base::~Base() { }
 
class Derived1 : public Base {
public:
   virtual ~Derived1() { 
   }
   
   virtual void quz() {
      std::cout << "derived 1 quz " << std::endl;
   }
};
 
class Derived2 : public Base {
public:
   virtual ~Derived2() { 
   }
   
   virtual void bar() {
      std::cout << "derived 2 bar " << std::endl;
   }
};
 
void foo(Base *p) {
   p->quz();
   p->foo();
   p->bar();
}
 
int main() {
   Base *p1 = new Derived1();
   Base *p2 = new Derived2();
      
   foo(p1);
   foo(p2);
   
   delete p1;
   delete p2;
   
   return 0;
}