Language: C++

    #include <iostream>
    #include <vector>
    #include <string>
    #include <sstream>
     
    class BigInteger {
    	// use 18 digit a element
    	std::vector<uint64_t> splited_num_;
    public:
    	BigInteger(std::string str) {
    		set_data(str);
    	}
    	BigInteger(std::vector<uint64_t>&& splited_num) {
    		splited_num_ = std::move(splited_num);
    	}
    	BigInteger operator+(const BigInteger& rhs) {
    		return BigInteger(plus(splited_num_, rhs.get_data()));
    	}
    	std::vector<uint64_t> get_data() const {return splited_num_;}
    	std::string to_string() const {
    		std::string ret("");
    		const int size = splited_num_.size();
    		for (int i = 0; i < size; ++i) {
    			const uint64_t& n = splited_num_[size - i - 1];
    			ret += n == 0 ? "000000000000000000" : std::to_string(n);
    		}
    		return ret;
    	}
    private:
    	void set_data(const std::string& str) {
    		std::string sub;
    		int length = str.length();
    		while (length >= 18) {
    			int pos = length - 18;
    			sub = str.substr(pos, 18);
    			splited_num_.push_back(to_uint64(sub));
    			length -= 18;
    		}
    		if (length > 0) {
    			sub = str.substr(0, length);
    			splited_num_.push_back(to_uint64(sub));
    		}
		}
    	std::vector<uint64_t> plus(std::vector<uint64_t> lhs,
    						       std::vector<uint64_t> rhs) const {
    		std::vector<uint64_t> ret;
     		uint64_t carry = 0;
     		
     		const int max = std::max(lhs.size(), rhs.size());
     		const int min = std::min(lhs.size(), rhs.size());
     		// ensure that lhs.sizs() is larger than rhs.size()
     		if (lhs.size() < rhs.size()) {
     			std::swap(lhs, rhs);
     		}
     		// fit container size
     		for (int i = 0; i < (max - min); ++i) {
     			rhs.push_back(0);
     		}
     		
     		for (int i = 0; i < max; ++i) {
     			uint64_t sum = lhs.at(i) + rhs.at(i) + carry;
     			carry = sum / 1000000000000000000;
     			sum = sum % 1000000000000000000;
     			ret.push_back(sum);
     		}
     		if (carry > 0) {
     			ret.push_back(carry);
     		}
     		return ret;
    	}
    	uint64_t to_uint64(const std::string& str) const {
    		std::istringstream iss(str);
    		uint64_t ret = 0;
    		iss >> ret;
    		return ret;
    	}
    };
     
    int main() {
    	std::vector<BigInteger> ans_list;
    	int n;
    	std::cin >> n;
    	for (int i = 0; i < n; ++i) {
    		std::string str1, str2;
    		std::cin >> str1;
    		std::cin >> str2;
    		BigInteger bi1(str1);
    		BigInteger bi2(str2);
    		ans_list.push_back(bi1 + bi2);
    	}
    	
    	for (auto ans : ans_list) {
    		std::cout << ans.to_string() << std::endl;
    	}
    }

Compiler output:
a.cc:8:21: error: 'uint64_t' was not declared in this scope
    8 |         std::vector<uint64_t> splited_num_;
      |                     ^~~~~~~~
a.cc:5:1: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
    4 |     #include <sstream>
  +++ |+#include <cstdint>
    5 | 
a.cc:8:29: error: template argument 1 is invalid
    8 |         std::vector<uint64_t> splited_num_;
      |                             ^
a.cc:8:29: error: template argument 2 is invalid
a.cc:13:32: error: 'uint64_t' was not declared in this scope
   13 |         BigInteger(std::vector<uint64_t>&& splited_num) {
      |                                ^~~~~~~~
a.cc:13:32: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc:13:40: error: template argument 1 is invalid
   13 |         BigInteger(std::vector<uint64_t>&& splited_num) {
      |                                        ^
a.cc:13:40: error: template argument 2 is invalid
a.cc:19:21: error: 'uint64_t' was not declared in this scope
   19 |         std::vector<uint64_t> get_data() const {return splited_num_;}
      |                     ^~~~~~~~
a.cc:19:21: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc:19:29: error: template argument 1 is invalid
   19 |         std::vector<uint64_t> get_data() const {return splited_num_;}
      |                             ^
a.cc:19:29: error: template argument 2 is invalid
a.cc:44:21: error: 'uint64_t' was not declared in this scope
   44 |         std::vector<uint64_t> plus(std::vector<uint64_t> lhs,
      |                     ^~~~~~~~
a.cc:44:21: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc:44:29: error: template argument 1 is invalid
   44 |         std::vector<uint64_t> plus(std::vector<uint64_t> lhs,
      |                             ^
a.cc:44:29: error: template argument 2 is invalid
a.cc:44:48: error: 'uint64_t' was not declared in this scope
   44 |         std::vector<uint64_t> plus(std::vector<uint64_t> lhs,
      |                                                ^~~~~~~~
a.cc:44:48: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc:44:56: error: template argument 1 is invalid
   44 |         std::vector<uint64_t> plus(std::vector<uint64_t> lhs,
      |                                                        ^
a.cc:44:56: error: template argument 2 is invalid
a.cc:45:68: error: 'uint64_t' was not declared in this scope
   45 |                                                        std::vector<uint64_t> rhs) const {
      |                                                                    ^~~~~~~~
a.cc:45:68: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc:45:76: error: template argument 1 is invalid
   45 |                                                        std::vector<uint64_t> rhs) const {
      |                                                                            ^
a.cc:45:76: error: template argument 2 is invalid
a.cc:71:9: error: 'uint64_t' does not name a type
   71 |         uint64_t to_uint64(const std::string& str) const {
      |         ^~~~~~~~
a.cc:71:9: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc: In member function 'std::string BigInteger::to_string() const':
a.cc:22:47: error: request for member 'size' in '((const BigInteger*)this)->BigInteger::splited_num_', which is of non-class type 'const int'
   22 |                 const int size = splited_num_.size();
      |                                               ^~~~
a.cc:24:31: error: 'uint64_t' does not name a type
   24 |                         const uint64_t& n = splited_num_[size - i - 1];
      |                               ^~~~~~~~
a.cc:24:31: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc:25:32: error: 'n' was not declared in this scope
   25 |                         ret += n == 0 ? "000000000000000000" : std::to_string(n);
      |                                ^
a.cc: In member function 'void BigInteger::set_data(const std::string&)':
a.cc:36:38: error: request for member 'push_back' in '((BigInteger*)this)->BigInteger::splited_num_', which is of non-class type 'int'
   36 |                         splited_num_.push_back(to_uint64(sub));
      |                                      ^~~~~~~~~
a.cc:36:48: error: 'to_uint64' was not declared in this scope
   36 |                         splited_num_.push_back(to_uint64(sub));
      |                                                ^~~~~~~~~
a.cc:41:38: error: request for member 'push_back' in '((BigInteger*)this)->BigInteger::splited_num_', which is of non-class type 'int'
   41 |                         splited_num_.push_back(to_uint64(sub));
      |                                      ^~~~~~~~~
a.cc:41:48: error: 'to_uint64' was not declared in this scope
   41 |                         splited_num_.push_back(to_uint64(sub));
      |                                                ^~~~~~~~~
a.cc: In member function 'int BigInteger::plus(int, int) const':
a.cc:46:29: error: 'uint64_t' was not declared in this scope
   46 |                 std::vector<uint64_t> ret;
      |                             ^~~~~~~~
a.cc:46:29: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
a.cc:46:37: error: template argument 1 is invalid
   46 |                 std::vector<uint64_t> ret;
      |                                     ^
a.cc:46:37: error: template argument 2 is invalid
a.cc:47:26: error: expected ';' before 'carry'
   47 |                 uint64_t carry = 0;
      |                          ^~~~~
a.cc:49:46: error: request for member 'size' in 'lhs', which is of non-class type 'int'
   49 |                 const int max = std::max(lhs.size(), rhs.size());
      |                                              ^~~~
a.cc:49:58: error: request for member 'size' in 'rhs', which is of non-class type 'int'
   49 |                 const int max = std::max(lhs.size(), rhs.size());
      |                                                          ^~~~
a.cc:50:46: error: request for member 'size' in 'lhs', which is of non-class type 'int'
   50 |                 const int min = std::min(lhs.size(), rhs.size());
      |                                              ^~~~
a.cc:50:58: error: request for member 'size' in 'rhs', which is of non-class type 'int'
   50 |                 const int min = std::min(lhs.size(), rhs.size());
      |                                                          ^~~~
a.cc:52:25: error: request for member 'size' in 'lhs', which is of non-class type 'int'
   52 |                 if (lhs.size() < rhs.size()) {
      |                         ^~~~
a.cc:52:38: error: request for member 'size' in 'rhs', which is of non-class type 'int'
   52 |                 if (lhs.size() < rhs.size()) {
      |                                      ^~~~
a.cc:57:29: error: request for member 'push_back' in 'rhs', which is of non-class type 'int'
   57 |                         rhs.push_back(0);
      |                             ^~~~~~~~~
a.cc:61:34: error: expected ';' before 'sum'
   61 |                         uint64_t sum = lhs.at(i) + rhs.at(i) + carry;
      |                                  ^~~
a.cc:62:25: error: 'carry' was not declared in this scope
   62 |                         carry = sum / 1000000000000000000;
      |                         ^~~~~
a.cc:62:33: error: 'sum' was not declared in this scope
   62 |                         carry = sum / 1000000000000000000;
      |                                 ^~~
a.cc:64:29: error: request for member 'push_back' in 'ret', which is of non-class type 'int'
   64 |                         ret.push_back(sum);
      |                             ^~~~~~~~~
a.cc:66:21: error: 'carry' was not declared in this scope
   66 |                 if (carry > 0) {
      |                     ^~~~~
a.cc:67:29: error: request for member 'push_back' in 'ret', which is of non-class type 'int'
   67 |                         ret.push_back(carry);
      |                             ^~~~~~~~~