Посоветуйте функции для арифметики больших целых чисел

std::string Add(const std::string&, const std::string&);
std::string Subtract(const std::string&, const std::string&);
std::string Multiply(const std::string&, const std::string&);
std::string Divide(const std::string&, const std::string&);
std::string Remainder(const std::string&, const std::string&);
std::string Power(const std::string&, const int);
std::string Factorial(const int);
std::string GCD(const std::string&, const std::string&);
std::string LCM(const std::string&, const std::string&);
std::string Abs(const std::string&);
std::string ISqrt(const std::string&);
std::string Fibonacci(const int);

BigInt a("123213");//вылетает исключение, если строка ошибочная (+1 проверка)
BigInt b("76876");//вылетает исключение, если строка ошибочная (+1 проверка)
BigInt c = Add(a, b);//a и b гарантированно содержат числа, проверки не требуются
BigInt d = Divide(a, b);//a и b гарантированно содержат числа, проверки не требуются
BigInt e = Power(a, b);//a и b гарантированно содержат числа, проверки не требуются
BigInt f = Add(c, Add(d, e));//c, d, e - гарантированно содержат числа, проверки не требуются
//итого: 2 проверки входных данных

std::string a("123213");//нет проверок
std::string b("76876");//нет проверок
std::string c = Add(a, b);//a и b могут быть любыми строками, нужна валидация (+2 проверки)
std::string d = Divide(a, b);//a и b могут быть любыми строками, нужна валидация (+2 проверки)
std::string e = Power(a, b);//a и b могут быть любыми строками, нужна валидация (+2 проверки)
std::string f = Add(c, Add(d, e));//c, d, e - могут быть любыми строками, нужна валидация (+4 проверки)
//итого: 10 проверок входных данных

std::string value; // будет хранить цифры
bool nan; // для определения корректности числа
bool neg; // для знака, чтобы определить, число отрицательное или неотрицательное (0 или положительное)

std::string value;
bool nan = true;
bool neg = false;

BigInt a; // "0"

BigInt a(); // "0"

BigInt a{}; // "0"

BigInt a = "-45";

BigInt a("-45");

BigInt a{"-45");

BigInt b(a);

BigInt b{a};

BigInt b = a;

class MyBigNum
{
    std::string value={1,'\0'}; //или '0' ? Не знаю, что у тебя там принято за значения разрядов
    
    struct s_flags
    {
        using T=unsigned char;
        
        T sign:1;//0 + ; 1 -
        T nan:1;//не число
        T inf:1;//бесконечность
        private:
        T reserv:5;
    }flags{};
    static_assert(sizeof(s_flags)==sizeof(s_flags::T));
    
public:
...
...
};

class BigInt
{
    std::string value;
    bool nan = true;
    bool sign = false;
public:
    // #1 default constructor
    BigInt()
    {
        nan = false;
        value = "0";
    }
 
    // #2 default constructor with parameter
    BigInt(const std::string& s)
    {
        value = s;
        nan = false;
    }
 
    // #3 copy constructor
    BigInt(const BigInt& x)
    {
        value = x.value;
        sign = x.sign;
        nan = x.nan;
    }
 
    // #4 copy assignment operator
    BigInt& operator=(const BigInt&)
    {
        return *this;
    }
};
 
int main()
{
    std::string x = "23";
 
    // #1
    BigInt a;
    BigInt b{};
 
    // #2
    BigInt c("10");
    BigInt d{"42"};
    BigInt e(x);
    BigInt f{x};
    BigInt g = x;
 
    // #3
    BigInt h(c);
    BigInt i{d};
    BigInt j = c;
 
    // #4
    a = h;
 
}

BigInt a = "13";
a = "24";

#include <string>
 
class BigInt
{
    std::string value{1,'0'};
    bool nan{};
    bool sign{};
public:
    BigInt()=default;
 
    BigInt(const std::string_view s):value{s}
    {
    }
};
 
int main()
{
    std::string x = "23";
 
    // #1
    BigInt a;
    BigInt b{};
 
    // #2
    BigInt c("10");
    BigInt d{"42"};
    BigInt e(x);
    BigInt f{x};
    BigInt g = BigInt{x};
 
    // #3
    BigInt h(c);
    BigInt i{d};
    BigInt j = c;
 
    // #4
    a = h;
    
    {
        BigInt a = BigInt{"13"};
        a = BigInt{"24"};    
    }
}

#include <iostream>
#include <cstring>
 
class BigInt
{
    std::string value;
    bool nan = true;
    bool sign = false;
public:
    // #1 default constructor
    BigInt()
    {
        nan = false;
        value = "0";
    }
 
    // #2 default constructor with parameter
    BigInt(const std::string& s)
    {
        value = s;
        nan = false;
    }
 
    // #3 copy constructor
    BigInt(const BigInt& x)
    {
        value = x.value;
        sign = x.sign;
        nan = x.nan;
    }
 
    // #4 copy assignment operator
    BigInt& operator=(const BigInt&)
    {
        return *this;
    }
    
    // #5 copy assignment operator
    BigInt& operator=(const char* s)
    {
        value = std::string(s);
        nan = false;
        return *this;
    }
    
    // #6 default constructor with parameter
    BigInt(const char* s)
    {
        value = std::string(s);
        nan = false;
    }
    
    // test
    void print(void)
    {
        std::cout << value << std::endl;
    }
};
 
int main()
{
    BigInt z="13"; // #6
    z.print();
    z = "24"; // #5
    z.print();
    
    return 0;
}

BigInt a = "13";
a = "24";

BigInt c("10");
BigInt d{"42"};

friend BigInt operator+(const BigInt&, const BigInt&);