Длинная арифметика: сложение и умножение чисел

#include <iostream>
#include <vector>
#include <string>
 
int CtI(char x) // char в int
{
    return int(x)-48;
}
 
char ItC(int x) // int в char
{
    return char(x+48);
}
 
std::string adapt(std::string x, std::string y) // дописываем нули
{
    std::string::iterator iter = y.begin();
        y.insert(iter, x.size() - y.size(), '0');
    return y;
}
 
std::string sum_func(std::string x, std::string y)
{
    
    std::string::iterator x_iter = x.begin();
    std::string::iterator y_iter = y.begin();
    x.insert(x_iter, '0');
    y.insert(y_iter, '0');
    if (x.size() > y.size())
        y = adapt(x,y);
    if (x.size() < y.size())
        x = adapt(y,x);
    std::string sum;
    std::string::iterator sum_iter = sum.begin();
    int temp = 0;
    for (x_iter = --x.end(), y_iter = --y.end(); x_iter != x.begin(); --x_iter, --y_iter) // для того, чтоб цикл выполнился до
    {                                                                                     // конца мы заранее добавили по нолику
        if (temp != 0)
        {
            sum.insert(sum_iter, ItC((CtI(*x_iter)+CtI(*y_iter))%10+temp));
            temp = 0;
        }
        else
            sum.insert(sum_iter, ItC((CtI(*x_iter)+CtI(*y_iter))%10));
        temp = (CtI(*x_iter)+CtI(*y_iter))/10;
    }
    if (temp != 0)
        sum.insert(sum_iter, ItC(temp));
    else
        sum.erase(sum_iter);
    return sum;
}
 
int main()
{
    std::string x, y;
    std::cin >> x >> y;
    std::cout << sum_func(x,y);
    std::cin.get(); std::cin.get(); 
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
 
void Output (std::string str)
{
    if (! str.empty())
        for (std::string::const_iterator str_iter = str.begin(); str_iter != str.end(); ++str_iter)
            std::cout << *str_iter;
    else
        std::cerr << "Error! The vector is empty!";
}
 
std::vector<int> StrToInt (std::string str)
{
    std::vector<int> vec;
    for (std::string::const_iterator str_iter = str.begin(); str_iter != str.end(); ++str_iter)
        vec.push_back(int(*str_iter));
    return vec;
}
 
std::string IntToStr (std::vector<int> vec)
{
    std::string str;
    for (std::vector<int>::const_iterator vec_iter = vec.begin(); vec_iter != vec.end(); ++vec_iter)
        str.push_back(char(*vec_iter));
    return str;
}
 
std::string Inverse (std::string str)
{
    std::string inv_str;
    std::string::const_iterator inv_str_iter = inv_str.begin();
    for (std::string::const_iterator str_iter = str.begin(); str_iter != str.end(); ++str_iter)
        inv_str.insert (inv_str_iter, *str_iter);
    return inv_str;
}
 
std::string Add (std::string str1, std::string str2)
{
    std::vector<int> vec1, vec2, vec_sum;
    vec1 = StrToInt (Inverse (str1));
    vec2 = StrToInt (Inverse (str2));
    std::vector<int>::const_iterator vec1_iter = vec1.begin();
    std::vector<int>::const_iterator vec2_iter = vec2.begin();
    int digit = 0;
    while (vec1_iter != vec1.end())
    {
        if (vec2_iter == vec2.end())
            vec2.push_back(0);
        if (digit != 0)
        {
            vec_sum.push_back ((*vec1_iter + *vec2_iter)%10 + digit);
            digit = 0;
        }
        else
            vec_sum.push_back ((*vec1_iter + *vec2_iter)%10);
        digit = (*vec1_iter + *vec2_iter)/10;
        ++vec1_iter;
        ++vec2_iter;
    }
    if (digit != 0) 
        vec_sum.push_back(1);
    return Inverse(IntToStr(vec_sum));
}
 
int main()
{
    std::string str1, str2;
    std::getline (std::cin, str1);
    std::getline (std::cin, str2);
    Output (Add (str1, str2));
    std::cin.get();
    return 0;
}

*it = *it - '0';

void inc1 (int& x){x +=1;}
void inc2 (int x) {x +=1;}
int main()
{
    int x = 0;  //x == 0
    inc1(x);    //x == 1
    inc2(x);    //x == 1
}

#include <iostream>
#include <string>
#include <vector>
const int BASE = 10;
 
void Input (std::string& str1, std::string& str2, char& oper)
{
    std::cout << "Please, input the 1st number: ";
    std::getline(std::cin, str1);
    std::cout << std::endl << "Please, input the 2nd number: ";
    std::getline(std::cin, str2);
    std::cout << std::endl << "Please, input the operation ('+','-' or '*'): ";
    std::cin.get(oper).get();
}
 
void Output (const std::string& str)
{
    for (std::string::const_iterator str_iter = str.begin(); str_iter != str.end(); ++str_iter)
            std::cout << *str_iter;
}
 
std::vector<int> StrToInt (const std::string& str)
{
    std::vector<int> vec(str.cbegin(), str.cend());
    
    for (auto iter = vec.begin(); iter!= vec.end(); ++iter)
    {
        *iter -= '0';
    }
    return vec;
}
 
std::string IntToStr (const std::vector<int>& vec)
{
    std::string str(vec.cbegin(), vec.cend());
 
    for (auto iter = str.begin(); iter!= str.end(); ++iter)
    {
        *iter += '0';
    }
    return str;
}
 
std::string Inverse (const std::string& str)
{
    std::string inv_str(str);
    std::reverse(inv_str.begin(), inv_str.end());
    return inv_str;
}
 
std::string Max (const std::string& str1, const std::string& str2)
{
    if (str1.size() > str2.size()) 
        return str1;
    if (str1.size() < str2.size()) 
        return str2;
 
    std::vector<int> vec1 = StrToInt (str1);
    std::vector<int> vec2 = StrToInt (str2);
 
    for (auto vec1_iter = vec1.cbegin(), vec2_iter = vec2.cbegin(); vec1_iter != vec1.end(); ++vec1_iter, ++vec2_iter)
    {
        if (*vec1_iter > *vec2_iter)
            return str1;
        if (*vec1_iter < *vec2_iter)
            return str2;
    }
 
    return str1;
}
 
std::string Add (const std::string& str1, const std::string& str2)
{
    std::vector<int> vec1 = StrToInt (Inverse (str1));
    std::vector<int> vec2 = StrToInt (Inverse (str2));
 
    int max_size = std::max(vec1.size(), vec2.size());
    vec1.resize(max_size);
    vec2.resize(max_size);
 
    std::vector<int> vec_sum;
    vec_sum.reserve(max_size);
    
    int digit = 0;
    for (auto vec1_iter = vec1.cbegin(), vec2_iter = vec2.cbegin(); vec1_iter != vec1.end(); ++vec1_iter, ++vec2_iter)
    {
        vec_sum.push_back((*vec1_iter + *vec2_iter + digit) % BASE);
        digit = (*vec1_iter + *vec2_iter) / BASE;
    }
    if (digit != 0) 
        vec_sum.push_back(digit);
 
    return Inverse(IntToStr(vec_sum));
}
 
std::string Multiple (const std::string& str1, const std::string& str2)
{
    std::vector<int> vec1 = StrToInt (Inverse (str1));
    std::vector<int> vec2 = StrToInt (Inverse (str2));
 
    int max_size = std::max(vec1.size(), vec2.size());
    vec1.resize(max_size);
    vec2.resize(max_size);
 
    std::string str_prod_sum;
    int n = 0;
    
    for (auto vec2_iter = vec2.begin(); vec2_iter != vec2.end(); ++vec2_iter)
    {
        std::vector<int> vec_prod(0);
        int digit = 0;
 
        for (int i = 0; i < n; ++i)
                vec_prod.push_back(0);
        ++n;
        
        for (auto vec1_iter = vec1.begin(); vec1_iter != vec1.end(); ++vec1_iter)
        {
            vec_prod.push_back((*vec1_iter * *vec2_iter + digit) % BASE);
            digit = (*vec1_iter * *vec2_iter + digit) / BASE;
        }
        if (digit != 0)
            vec_prod.push_back(digit);
 
        str_prod_sum = Add (Inverse(IntToStr(vec_prod)), str_prod_sum);
    }
 
    return str_prod_sum;
}
 
std::string Subtract (const std::string& str1, const std::string& str2)
{
    std::vector<int> vec1 = StrToInt (Inverse (str1));
    std::vector<int> vec2 = StrToInt (Inverse (str2));
 
    int max_size = std::max(vec1.size(), vec2.size());
    vec1.resize(max_size);
    vec2.resize(max_size);
    
    std::vector<int> vec_sub;
    vec_sub.reserve(max_size);
 
    int digit = 0;
    for (auto vec1_iter = vec1.cbegin(), vec2_iter = vec2.cbegin(); vec1_iter != vec1.end(); ++vec1_iter, ++vec2_iter)
    {
        if ((*vec1_iter - digit) >= *vec2_iter)
        {
            vec_sub.push_back (*vec1_iter - digit - *vec2_iter);
            digit = 0;
        }
        else
        {
            vec_sub.push_back (*vec1_iter + BASE - digit - *vec2_iter);
            digit = 1;
        }
    }
 
    while (vec_sub.back() == 0)
        vec_sub.pop_back();
 
    return Inverse(IntToStr(vec_sub));
}
 
void Result (const std::string& str1, const std::string& str2, const char& oper)
{
    std::cout << std::endl << "Result is: ";
    switch (oper)
    {
        case '+':
            Output (Add (str1, str2));
            break;
        case '*':
                Output (Multiple (str1, str2));
            break;
        case '-':
            if (str1 != Max(str1, str2))
            {
                std::cout << '-';
                Output (Subtract (str2, str1));
            }
            else
                Output (Subtract (str1, str2));
            break;
        default:
            std::cerr << "Error! Try again";
    }
}
 
int main()
{
    std::string str1, str2;
    char oper;
    Input (str1, str2, oper);
    Result (str1, str2, oper);
    std::cin.get();
    return 0;
}