Mam do zrobienia program który ma przeliczać np liczbę 4M na 4 000 000 i tak samo Billion, Trillion.....

#include <iostream>
#include <string>
#include <stdlib.h>

using namespace std;
int trans(char a ) {
	switch (a) {
	case 'M':return a * 100000; break;
	case 'B':return a * 1000000000; break;
	case 'T':return a * 1000000000000; break;
	case 'Qa':return a * 1000000000000000; break;
	case 'Qi':return a * 1000000000000000000; break;
	case 'Sx':return a * 1000000000000000000000; break;
	case 'Sp':return a * 1000000000000000000000000; break;
	case 'Oc':return a * 1000000000000000000000000000; break;
	default: return 0; break;
	}
}
int main()
{
	char literki[12][255] = { " ", "M", "B", "T", "Qa", "Qi", "Sx",
		"Sp", "Oc", '\0' };

    
	string a;
	cout << "Podaj cyfre z litera: ";
	cin >> a;
	
	int element = 0, wynik = 0, temp = 0;
	for (int i = 0; i<a.length(); ++i)
	{
		element = trans(a.at(i));
		if (i<a.length() - 1) {
			temp = trans(a.at(i + 1));
		}
		if (temp>element)
		{
			element = 0 - element;
		}
		wynik = element + wynik;
	}
	cout << wynik;

	return 0;
}

Czy zmienna typu char może przyjąć wartość 'Qa'?

Po pierwsze char to jeden znak, czyli wszystko co poniżej 'T' zwyczajnie "zbuguje" ci program.
Po drugie zakres zmiennych, w int "zmieścisz" trochę ponad 2 miliardy 147 milionów.
po trzecie ja bym zrobił to na string-ach, do części z cyframi dokleił gotowca z odpowiednią ilością zer i gotowe

Zdecydowanie na stringach,(funkcja nie validuje wejścia) pseudokod, prawie taki sam jak python:

def translate(s):
    L = ["Q", "S", "O"]# [1]
    f = {"M": 1000000, "B": 1000000000, "T": 1000000000000, "Qa": 1000000000000000} #[2]
    if s[-2] in L:#[3]
        cnt = 2 
        h_ind = s[-2] + s[-1] 
    else:
        cnt = 1
        h_ind = s[-1]# [4]
    tmp = int(s[:-cnt])# [5]
    return tmp * f[h_ind] #[6]

#[1] - lista przedostatnich znaków, gdy nazwa wielkiej liczby będzie dwuliterowa
#[2] - hashmapa <string, biginteger> z nazwami wielkich liczb i mnożnikami
#od [3] do [4] - Jeśli przedostatni element wejścia jest w liście [1] (s[-2] to w pythonie przedostatni elemnent
#tablicy/stringa) to cnt = 2 - dwa elementy które są literkami do obcięcia oraz h_ind = s[-2] + s[-1]
#czyli klucz do wyciagniecia wartości z hashmapy to konkatenacja dwóch ostatnich elementów (s[-1] ostatni element w pytnonie)

w przeciwnym przypadku (else) cnt = 1 (obcianamy 1 element, ostatni) a klucz to ostatni element wejściowego stringa

[5] - to co już wiemy: zamieniamy na liczbę wszystko co nie jest literami w wejściu

[6] - i zwracamy liczbę z odpowiednią ilością zer

f[h_ind] w tej składni to wyciągnięcie wartości z hashmapy odpowiadającej kluczowi h_ind (mnożenie przez 10, 100, 1000.... to dodawanie zer)

Niestety do obsługi tak wielkich liczb Musisz użyć bigintegerów, a to skomplikuje kod C++ (jak widac nie pythona), dlatego napisałem to tak, bo idea jest jasna

https://wandbox.org/permlink/nAzTqnFBjMfnfE1x