заполнение массива в зависимости от введённого типа данных

Делаем функции для проверки содержимого строки:

inline bool isInteger(const std::string & s)
{
   if(s.empty() || ((!isdigit(s[0])) && (s[0] != '-') && (s[0] != '+'))) return false;
   char* end;
   strtol(s.c_str(), &end, 10);
   return (* end == 0);
}
inline bool isDouble(const std::string & s)
{
    char* end = 0;
    double val = strtod(s.c_str(), &end);
    return end != s.c_str() && *end == '\0' && val != HUGE_VAL;
}

Дальше остаётся лишь их применить и совершить нужные действия. Что-то вроде этого:

void processUserInput(const std::string & s)
{
    if (isDouble(s)) {
        // Переводите в double и сохраняйте в ваш массив
    } else if (isInteger(s)) {
        // Переводите в int и сохраняйте в ваш массив
    } else {
        // Сохраняйте строку в массив char или что там у вас
    }
}

Вы не дали четких пояснений как именно вам нужно идентифицировать тип. Допустим вы вводите GT200к. Вы хотите рассматривать 200 как отдельное число?.. Такого типа вопросов может возникать много, поэтому точного ответа нет, но примерно так:

Псевдокод:

Объявления

char s;
double n;

Теперь вводим символы:

while (cin >> s && !isdigit(s)) {
    //храним в символьном массиве(контейнере)
}

Если это не конец ввода

if (s != cin.eof())

то прочли цифру. Положим обратно в буфер и прочтем в double

cin >> n;

Если это целое число

if (floor(n + 0.5) == n)

храним в последовательности целых, в обратном случаи как double Делаем это до конца ввода или сколько раз нужно.

До С++11, ключевое слово auto использовалось как спецификатор хранения переменной (как, например, register, static, extern). В С++11 auto позволяет не указывать тип переменной явно, говоря компилятору, чтобы он сам определил фактический тип переменной, на основе типа инициализируемого значения. Это может использоваться при объявлении переменных в различных областях видимости, как, например, пространство имен, блоки, инициализация в цикле и т.п.

auto i = 42;        // i - int
auto l = 42LL;      // l - long long
auto p = new foo(); // p - foo*

Использование auto позволяет сократить код (если, конечно, тип не int, который на одну букву меньше). Подумайте об итераторах STL, которые вы должны были всегда писать для прохода контейнеров. Таким образом, это делает устаревшим определение typedef только ради простоты.

std::map<std::string, std::vector<int>> map;
for(auto it = begin(map); it != end(map); ++it) 
{
   // do smth
}
// Или, сравним С++03 и С++11
// C++03
for (std::vector<std::map<int, std::string>>::const_iterator it = container.begin(); it != container.end(); ++it)
{
   // do smth
}
// C++11
for (auto it = container.begin(); it != container.end(); ++it)
{
   // do smth
}

Стоить отметить, что возвращаемое значение не может быть auto. Однако, вы можете использовать auto вместо типа возвращаемого значения функции. В таком случае, auto не говорит компилятору, что он должен определить тип, он только дает ему команду искать возвращаемый тип в конце функции. В примере ниже, возвращаемый тип функции compose — это возвращаемый тип оператора +, который суммирует значения типа T и E. template auto compose(T a, E b) -> decltype(a+b) // decltype - позволяет определить тип на основе входного параметра

{
   return a+b;
}
auto c = compose(2, 3.14); // c - double

Взято из хабра