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

В C++ есть определенный набор "встроенных" типов:

bool
char 
int
float 
double
void 
wchar_t

Вы не можете изменит их размер.

Если вы хотите создать новый тип, то можете объявить структуру, скажем, super_long_double, которая будет хранить 32 байта (char[32]), и добавить перегрузки нужных вам операторов для этой структуры - будь то плюс, минус и тд.

Ну например:

// Ваша структура
struct super_long_double {
    // Данные (32 байта)
    char data[32];    
    // Конструктор по-умолчанию (инициализируйте тут ваш тип)
    super_long_double() { /* Тут логика */ }
    // Конструктор, принимающий double. Для удобной инициализации
    super_long_double(double value) { /* И тут логика */ }
    // Оператор суммы
    super_long_double operator+(const super_long_double &rhl) {
        super_long_double result;
        // Тут логика сложения
        return result;
    }
   // Оператор типа double, для удобного выведения в консоль
    operator double() const {
        // Вернуть какое-то значение
        return 0.31512345;
    }
};
int main() {
    // Удобная инициализация (см. 2 конструктор)
    super_long_double s = 0.21412;
    super_long_double d;
    // Вывод в консоль 
    // (неявное приведение суммы к double, см. operator double)
    cout << (s + d) << endl;
    return 0;
}

Так как операции над double, long и прочими типами описаны в стандартах, и в большинстве случаев поддерживаются (или ускоряются, как вам будет угодно) процессором, то вы не можете просто взять и расширить существующий тип.

Если вы определяете свой тип так, как я показал, то вам придется для каждой арифметической (а может, и не только) операции писать собственную логику. И такие операции, увы, будут производится не в одно, а в несколько, может несколько десятков операций, т.е. операции с такими типами будут производиться в разы дольше.

Поэтому использовать такой подход стоит лишь тогда, когда вам нужно, к примеру, сделать тип с запятой для каких-то вычислений, связанных с деньгами (чтобы не потерять мелочь), ну или же когда вам нужно считать огроооооомные числа, что не помещаются в встроенные типы.

Но тогда возникает другой вопрос - а все ли вы делаете правильно?

ну например написать такой класс (я его писал для решения конкретной задачи)

class Lengthy2num {
public:
    Lengthy2num(const string& firstNumber)
        : s1(firstNumber)
    {
        remake(s1);
        p = comma_pos();
    }
    Lengthy2num& operator +=(string);
    Lengthy2num& operator -=(string);
    Lengthy2num& operator /=(string);
    Lengthy2num& operator *=(string);
    operator string() const     { return s1; }
    size_t get_comma() const    { return p; }
    friend std::ostream& operator <<(std::ostream& os, const Lengthy2num& Ln)
    { os << Ln.s1;     return os;}
private:    
    string s1;
    size_t p;
    void remake(string&);
    std::pair<std::string, char > add(string&);
    size_t comma_pos() const;
};

Он работает с цифрами любой длины но реализовать его не так то просто, чтобы сложность была небольшая