C++中需存储10^21的数值类型选型：unsigned long long不足时如何处理

Great question! Since unsigned long long maxes out at ~1.8×10^19, it's definitely too small for your 10^21 requirement. Here are three practical solutions, ordered by ease of use:

1. Use unsigned __int128 (Compiler Extension) #

If you're using GCC, Clang, or most modern compilers, this is the quickest fix. unsigned __int128 can hold values up to 2^128 - 1 (~3.4×10^38), which easily covers 10^21. The only catch is that standard C++ I/O functions (like cout or printf) don't support it natively, so you'll need a simple helper function to print the value.

Example code:

#include <iostream>
using namespace std;

// Helper function to print unsigned __int128
void print_uint128(unsigned __int128 num) {
    if (num == 0) {
        cout << "0";
        return;
    }
    char buffer[40]; // Enough space for max uint128 value
    int idx = 0;
    while (num > 0) {
        buffer[idx++] = (num % 10) + '0';
        num /= 10;
    }
    // Print in reverse order
    while (idx > 0) {
        cout << buffer[--idx];
    }
}

int main() {
    unsigned __int128 big_value = 1000000000000000000000ULL; // 10^21
    print_uint128(big_value); // Outputs: 1000000000000000000000
    cout << endl;
    return 0;
}

Pros: No external dependencies, fast, minimal code changes.
Cons: Not part of standard C++ (won't work with MSVC without workarounds).

2. Use a Third-Party Big Integer Library #

For a more portable, feature-rich solution, use a dedicated big integer library. Two popular options are:

• Boost.Multiprecision: A header-only library that integrates seamlessly with C++ standard features.
• GMP (GNU Multiple Precision Arithmetic Library): A powerful C library with C++ bindings, ideal for heavy-duty number crunching.

Example with Boost.Multiprecision:

#include <iostream>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;
using namespace std;

int main() {
    cpp_int big_value = 1000000000000000000000LL;
    cout << big_value << endl; // Directly prints 10^21
    // You can also do arithmetic operations easily:
    cpp_int result = big_value * 2;
    cout << result << endl; // Outputs: 2000000000000000000000
    return 0;
}

Pros: Standard-compliant, supports all arithmetic operations, native I/O support, portable.
Cons: Requires linking against Boost or GMP (Boost is easier for header-only use).

3. Implement Your Own Big Integer Class #

If you want full control or can't use external libraries, you can build a simple big integer class using an array or string to store digits. This involves implementing basic operations like addition, multiplication, and conversion from strings/integers.

Example of a minimal string-based big integer (simplified):

#include <iostream>
#include <string>
using namespace std;

class BigInt {
private:
    string digits;
public:
    BigInt(const string& num_str) : digits(num_str) {}
    
    // Overload << for output
    friend ostream& operator<<(ostream& os, const BigInt& bi) {
        os << bi.digits;
        return os;
    }
    // Add more operations (multiplication, etc.) as needed
};

int main() {
    BigInt big_value("1000000000000000000000");
    cout << big_value << endl;
    return 0;
}

Pros: No external dependencies, fully customizable.
Cons: Time-consuming to implement correctly (easy to introduce bugs), less efficient than optimized libraries.

内容的提问来源于stack exchange，提问作者asn