Массив разных типов

Один из вариантов:

#include <iostream>
#include <vector>
union my_type
{
    double d;
    char sym;
    int num;
};
int main()
{
    std::vector<my_type> mas;
    my_type x;
    x.d = 1.1;
    mas.push_back(x);
    x.sym = 's';
    mas.push_back(x);
    x.num = -2;
    mas.push_back(x);
    std::cout << "{" << mas[0].d << "," << mas[1].sym << "," << mas[2].num << "}" << std::endl;
    return 0;
}

Но в этом случае вам придётся самому помнить, в какой индекс вектора какой реально тип вы положили.

Можно также создать std::vector<void*> , но за тем, какой тип вы положите туда, придётся следить самостоятельно (плюс в этом случае контроль за очисткой памяти ложится на вас).

1. Использовать std::tuple вместо массива. Придется немного еще потрудиться, чтобы создать итератор для такого хранилища.

2. Использовать старинный union. Non-type-safe. Можно придать юниону тег:

struct Element { enum { D, C, I } type; union { double d; char c; int i; } data; };

и получить run-time type resolution, и сделать C++ немного более динамическим языком.

3. Можно обобщить 2. и сделать какой-нибудь совсем обобщенный boxed type. Ну или использовать std::variant. Или свой простенький variant: три поля разных типов, три конструктора с аргументами разных типов, три оператора приведения к разным типам, тег конкретного типа.

Вариантов тьма, не сочтите за каламбур.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class someType {
public:
    someType() = default;
    ~someType() = default;
    virtual void print(ostream&) {}
    friend ostream& operator << (ostream &os, someType *&value);
    virtual double getData() {};
};
ostream& operator << (ostream &os, someType *&value){
    value->print(os);
    return os;
}
class doubleType : public someType {
private:
    double data;
public:
    doubleType(double data) : someType() {
        this->data = data;
    }
    void print(ostream& os){
        os << data;
    }
    double getData(){
        return data;
    }
};

class intType : public someType {
private:
    int data;
public:
    intType(int data) : someType() {
        this->data = data;
    }
    void print(ostream& os){
        os << data;
    }
    double getData(){
        return data;
    }
};
class charType : public someType {
private:
    char data;
public:
    charType(char data) : someType() {
        this->data = data;
    }
    void print(ostream& os){
        os << data;
    }
    double getData(){
        return data;
    }
};

int main(){
    vector<someType*> el;
    el.push_back(new charType('z'));
    el.push_back(new intType(10));
    el.push_back(new doubleType(10.01));
    el.push_back(new charType('c'));

    for_each(el.begin(), el.end(), [](someType* value) -> void {
        cout << value << endl;
    });
    sort(el.begin(), el.end(), [] (someType* first, someType* second) -> bool {
        return first->getData() < second->getData();
    });
    for_each(el.begin(), el.end(), [](someType* value) -> void {
        cout << value << endl;
    });
}

https://ideone.com/uTcl2V

stdout:

До сортировки
z
10
10.01
c
После
10
10.01
c
z

Сортировка с преобразованием к double. (К комментарию в вопросе) Свой способ сортировки вы можете задать в лямбда функции указанной в функции sort().

• Базовый класс: someType
• Его наследники: doubleType, intType

Самый обычный полиморфизм:

1. создаете любой контейнер или просто массив
2. тип контейнера должен быть указателем на базовый класс
3. далее просто выделяете память под нужного вам наследника

Каждый наследник имеет поле с соответствующим ему типом данных.