Как записать два разных класса в массив?

vector<class_a> cont_a;
vector<class_b> cont_b;
// тут мы их заполнили допустим по 800 элементов в каждом векторе.

#include <iostream>
#include <string>
#include <vector>
#include <memory>
 
class Base {
public:
  virtual std::string getName() = 0;
};
 
class Foo: public Base {
public:
  std::string getName() { return std::string("Foo"); };
};
 
class Bar: public Base {
public:
  std::string getName() { return std::string("Bar"); };
};
 
 
int main() {
  std::vector< std::shared_ptr<Base> > xs;
 
  xs.push_back( std::static_pointer_cast<Base>(std::make_shared<Foo>()) );
  xs.push_back( std::static_pointer_cast<Base>(std::make_shared<Bar>()) );
  xs.push_back( std::static_pointer_cast<Base>(std::make_shared<Bar>()) );
  xs.push_back( std::static_pointer_cast<Base>(std::make_shared<Foo>()) );
 
  for(auto x: xs) {
    std::cout << x->getName() << std::endl;
  }
 
  return 0;
}

#include <iostream>
#include <vector>
#include <string>
 
 
template < typename Type1 , typename Type2 >
struct pointer_pair
{
 
    pointer_pair ( Type1 * pFirst )
        : first ( pFirst )
        , second ( nullptr )
    {
    }
 
    pointer_pair ( Type2 * pSecond )
        : first ( nullptr )
        , second ( pSecond )
    {
    }
    Type1 * first ;
    Type2 * second ;
};
 
 
template < typename T1, typename T2 >
std::ostream & operator << ( std::ostream & stream , const pointer_pair<T1,T2> & obj )
{
    if ( obj.first )
        stream << *obj.first ;
    else if ( obj.second )
        stream << *obj.second ;
    return stream ;
}
 
 
template < typename T >
std::ostream & operator << ( std::ostream & stream , const std::vector<T> & vec )
{
    for ( const auto & e : vec )
        stream << e << '\n' ;
    return stream ;
}
 
 
 
int main()
{
    std::vector < pointer_pair < std::string , double > > vec ;
    vec.push_back ( { new std::string("my string 1") } ) ;
    vec.push_back ( { new std::string("my string 2") } ) ;
    vec.push_back ( { new double(3.14) } ) ;
    vec.push_back ( { new std::string("my string 3") } ) ;
    vec.push_back ( { new double(-0.23) } ) ;
    std::cout << vec << std::endl ;
    //тут delete
}

#include <iostream>
#include <vector>
 
class base {
    public:
        virtual ~base() {/*make it polymorphical*/};
};
 
class classA : public base {
    public:
        void methodA() {
            std::cout << "A.methodA()" << std::endl;
        }
};
 
class classB : public base {
    public:
        void methodB() {
            std::cout << "B.methodB()" << std::endl;
        }
};
 
int main() {
    std::vector <base *> vector;
    for (size_t i = 0; i < 10; i++) {
        if (!(i % 2)) {
            vector.push_back(new classA());
        } else {
            vector.push_back(new classB());
        }
    }
    for (base *currentClass : vector) {
        if (dynamic_cast <classA *>(currentClass)) {
            ((classA *)currentClass)->methodA();
        } else {
            ((classB *)currentClass)->methodB();
        }
    }
    
    return 0;
}

    std::shared_ptr<Foo> foo = std::dynamic_pointer_cast<Foo>(x);
    if (foo) {
      std::cout << foo->getFooFoo() << std::endl;
    }

#include <iostream>
 
// --- типы, объекты которых предполагается хранить в зоопарк-массиве.
struct sample1
{
    int ar;
};
 
struct sample2
{
    double v;
};
 
// ---------------------------------------------------
// юнион гарантирует выравнивание
// и адекватный размер элемента массива
 
union element
{
    element(sample1 s)
        :s1(s)
    {}
    
    element(sample2 s)
        :s2(s)
    {}
    
    sample1 s1;
    sample2 s2;
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    sample1 s1;
    sample2 s2;
   
    // --- и вуаля!
    element arr[] = { s1, s2 };
}

//Title of this code
//g++  4.9.1
 
#include <iostream>
 
 
struct sample1
{
    int ar;
};
 
struct sample2
{
    double v=25.5;
};
 
 
// --- только для иллюстрации!!!
// не рекомендованно для использования на бою
 
struct wrapper
{
    // в коде отсутствует thread-safe защита
    // в коде отсутствует exception-safe защита
    // в коде отсутствует диструктор, так что могут быть утечки памят
    // не учитывается выравнимвание
    // отсутствует защита типизации и квалификаторов
    
    // и вообще, я вырезал все, что бы не захламлять обзор
    // так что не нужно в таком виде такое использовать
    
    enum { eSIZE = sizeof(sample1)>sizeof(sample2)? sizeof(sample1): sizeof(sample2) };
    
    template<class U>
    wrapper(U&& v)
    {
        typedef typename std::remove_reference<U>::type
            type;
        
        static_assert(
            sizeof(type)<=eSIZE,
            "ERROR: INVALID SIZE"
        );
        
        new (mBuf) type(v);
    }
    
    template<class T>
    operator T&()
    {
        T* p = reinterpret_cast<T*>(mBuf);
        return *p;
    }
    
    char mBuf[eSIZE];
};
 
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    sample1 s1;
    sample2 s2;
    
    
    wrapper arr[] = { s1, s2 };
    
    sample2& ref = arr[1];
    
    std::cout<<"(must be 25.5): " << ref.v <<std::endl;
    
}