#include <bits/stdc++.h>

class decimal
{
private:
	char *number; // number stores the reversed raw_data
	int64_t _raw_size;
	int64_t _size;
	inline void expand(int64_t new_size);
	inline char safe_at(int64_t x);

public:
	decimal();
	decimal(decimal &x);
	decimal(const char *s);
	decimal(const std::string s);
	~decimal();
	inline char & at(int64_t x);
	inline int64_t size();
	inline void resize(int64_t new_size);
	inline void push_digit(char x);
	void print();
	decimal add(decimal x);
};

decimal::decimal()
{
	_size = 0;
	_raw_size = 0;
	number = NULL;
}

decimal::decimal(decimal &x)
{
	_size = x._size;
	_raw_size = x._size;
	number = (char *)malloc(_size);
	memcpy(number, x.number, _size);
}

decimal::decimal(const char *s)
{
	_size = 0;
	_raw_size = strlen(s);
	number = (char *)malloc(_raw_size);
	bool flag = true;
	for (int64_t i = 0; i < _raw_size; i++)
	{
		if (flag)
		{
			if (s[i] != '0')
			{
				flag = false;
				i--;
			}
			else
				_size++;
		}
		else
			number[i - _size] = s[_raw_size - i + _size - 1];
	}
	if (flag)
	{
		number[0] = '0';
		_size = 1;
	}
	else
		_size = _raw_size - _size;
}

decimal::decimal(const std::string s)
{
	_size = 0;
	_raw_size = s.size();
	number = (char *)malloc(_raw_size);
	bool flag = true;
	for (int64_t i = 0; i < _raw_size; i++)
	{
		if (flag)
		{
			if (s[i] != '0')
			{
				flag = false;
				i--;
			}
			else
				_size++;
		}
		else
			number[i - _size] = s[_raw_size - i - 1];
	}
	if (flag)
	{
		number[0] = '0';
		_size = 1;
	}
	else
		_size = _raw_size - _size;
}

decimal::~decimal()
{
	if (number == NULL)
		return;
	free(number);
	number = NULL;
	_raw_size = 0;
}

inline void decimal::expand(int64_t new_size)
{
	resize(std::max(new_size, _raw_size << 1));
}

inline char & decimal::at(int64_t x)
{
	if (x >= _raw_size)
	{
		expand(x + 1);
		number[x] = '0';
	}
	else if (x >= _size)
		number[x] = '0';
	return number[x];
}

inline int64_t decimal::size()
{
	return _size;
}

void decimal::print()
{
	for (int64_t i = _size - 1; i >= 0; i--)
		putchar(number[i]);
}

inline void decimal::resize(int64_t new_size)
{
	char *ret = (char *)realloc(number, new_size);
	if (ret == NULL)
		throw "decimal::expand(): not enough memory to expand!";
	else
	{
		_raw_size = new_size;
		number = ret;
	}
}

inline char decimal::safe_at(int64_t x)
{
	if (x >= _size)
		return '0';
	return number[x];
}

inline void decimal::push_digit(char x)
{
	if (_size == _raw_size)
		expand(0);
	number[_size] = x;
	_size++;
}

decimal decimal::add(decimal x)
{
	decimal ret;
	int64_t max_size = std::max(x.size(), _size);
	ret.resize(max_size + 1);
	uint8_t value;
	uint8_t carry_bit = 0;
	for (int64_t i = 0; i < max_size; i++)
	{
		value = x.safe_at(i) + safe_at(i) + carry_bit - '0';
		if (value > '9')
		{
			value -= 10;
			carry_bit = 1;
		}
		else
			carry_bit = 0;
		ret.push_digit(value);
	}
	if (carry_bit)
		ret.push_digit('1');
	return ret;
}

void test()
{
	std::string a, b;
	std::cin >> a >> b;
	decimal x(a), y(b);
	decimal result = x.add(y);
	result.print();
}

int main()
{
	test();
	return 0;
}

本来想玩一波花的，结果洛谷甩给我一个编译错误，在自己的linux上拿g++编译没有问题，洛谷报错：

/tmp/compiler_tcy_od82/src: 在函数‘void test()’中:
/tmp/compiler_tcy_od82/src:194:24: 错误：cannot bind non-const lvalue reference of type ‘decimal&’ to an rvalue of type ‘decimal’
  194 |  decimal result = x.add(y);
      |                   ~~~~~^~~
/tmp/compiler_tcy_od82/src:33:27: 附注：  初始化‘decimal::decimal(decimal&)’的实参 1
   33 | decimal::decimal(decimal &x)
      |                  ~~~~~~~~~^

求助啊各位