C++ 用数学方法加两个字符串？

我在论坛上四处寻找，仍然找不到我问题的答案。 我有两个字符串，它们实际上是一个数字数组。例如（我只是选择随机数

    string input1="12345678909876543212";
    string input2="12345";

我想把这两个字符串加在一起，但把它们当作整数。 我的目标是创建一个类，在这个类中我可以添加比（long-long-int）更大的数字，这样它就可以超过最大的long-long-int变量

所以我没问题地解开了绳子，现在就到了

  input1="21234567890987654321" 
  input2="54321"

然后我尝试添加，比如说input1[0]+input2[0]（2+5）到一个新字符串，我们称之为newString[0]，其中等于（7）；但是我找不到一个好方法来临时转换字符串中的当前数字，以便我可以将其添加到新字符串中？有人能帮忙吗？我对atoi、stof、stod感到厌倦。它们似乎对我根本不起作用。 我可以用任何方法使这个函数工作。

---

我不在乎如何制作这个类，我只是想找到一种方法来在数学上添加这两个字符串，但是仍然保持了新字符串的字符串格式。谢谢你们能为我解决这个问题的< < /p> < p>我不是一个非常有C++的人，但是我们不能这样做吗？

   int i = stoi( input1[0]); 
     int j = stoi( input2[0]);
     int x = i+j;

---

请注意，这可以在C++11中完成。请参阅，也可以通过从字符中减去“0”将字符转换为整数：

char sumdigit = (input1[0]-'0') + (input2[0]-'0') + '0';

atoi（）

将

input[0]

转换为int是更好的选择：

int temp = atoi(input.substr(0,1).c_str());

然后使用stringstream将其转换回字符串：

stringstream convert;
convert << temp;
string newString = convert.str();

stringstream转换；
convert好吧，假设你唯一的问题是逻辑，而不是类设计，我提出了这个逻辑


用0填充输入，检查长度，匹配长度
像普通加法一样添加，跟踪进位
最后从结果中删除前导零

因此，在反向迭代器上使用lambda函数：-

char carry = 0;

std::transform(input1.rbegin(),input1.rend(),input2.rbegin(),
              result.rbegin(),[&carry]( char x,  char y){
    char z = (x-'0')+(y-'0') + carry;
    if (z > 9)
    {
        carry = 1;
        z -= 10;
    }
    else
    {
        carry = 0;
    }
    return z + '0';
});

//And finally the last carry
result[0] = carry + '0';

//Remove the leading zero
n = result.find_first_not_of("0");
if (n != string::npos)
{
    result = result.substr(n);
}

看

编辑“你能评论一下你在这里做什么吗？”

std:：transform
出现在标题
中，请参阅ideone发布的链接。
这里有一个解决方案，但这远没有意义，甚至一点都不好笑

GCC 4.7.3:g++-Wall-Wextra-std=c++0x dumb-big-num.cpp

#include <algorithm>
#include <cctype>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>

// dumb big num
// unsigned integer
class DBN {
public:
  DBN() : num("0") {}

  explicit DBN(const std::string& s) : num(s) {
    for (const auto& c : num) {
      if (!std::isdigit(c)) { throw std::invalid_argument("DBN::DBN"); } }
    std::reverse(std::begin(num), std::end(num)); }

  DBN operator+(const DBN& rhs) const {
    DBN tmp(*this);
    return tmp += rhs; }

  DBN& operator+=(const DBN& rhs) {
    std::string r;
    const int m = std::min(num.size(), rhs.num.size());
    int c = 0;
    for (int i = 0; i < m; ++i) {
      int s = (num[i] - '0') + (rhs.num[i] - '0') + c;
      c = s / 10;
      s %= 10;
      r += static_cast<char>('0' + s); }
    const std::string& ref = num.size() < rhs.num.size() ? rhs.num : num;
    for (int i = m; i < ref.size(); ++i) {
      int s = (ref[i] - '0') + c;
      c = s / 10;
      s %= 10;
      r += static_cast<char>('0' + s); }
    if (0 < c) { r += '1'; }
    num = r;
    return *this; }

  friend std::ostream& operator<<(std::ostream& os, const DBN& rhs);
  friend std::istream& operator>>(std::istream& os, DBN& rhs);

private:
  std::string num;
};


std::ostream& operator<<(std::ostream& os, const DBN& rhs) {
  std::string s(rhs.num);
  std::reverse(std::begin(s), std::end(s));
  return os << s;
}

std::istream& operator>>(std::istream& is, DBN& rhs) {
  std::stringstream ss;
  char c;
  while (is && std::isspace(is.peek())) { is.ignore(); }
  while (is) {
    if (!std::isdigit(is.peek())) { break; }
    is >> c;
    ss << c; }
  DBN n(ss.str());
  rhs = n;
  return is;
}

int main() {
  DBN a, b, t;
  while (std::cin >> a >> b) {
    std::cout << a + b << "\n";
    (t += a) += b;
  }
  std::cout << t << "\n";
}

#包括
#包括
#包括
#包括
#包括
#包括
//愚蠢的大数字
//无符号整数
类DBN{
公众：
DBN（）：num（“0”）{}
显式DBN（const std:：string&s）：num（s）{
用于（常量自动和c:num）{
如果（！std:：isdigit（c））{throw std:：invalid_参数（“DBN:：DBN”）；}
std:：reverse（std:：begin（num），std:：end（num））；}
DBN运算符+（常数DBN和rhs）常数{
DBN tmp（*本）；
返回tmp+=rhs；}
DBN和运算符+=（常量DBN和rhs）{
std：：字符串r；
常量int m=std:：min（num.size（），rhs.num.size（））；
int c=0；
对于（int i=0；ic；
ss>a>>b）{
std：：cout这里有一个添加两个表示为字符串的数字的解决方案

#include<iostream>
using namespace std;

string add(string a, string b)
{
   int al=a.size()-1;
   int bl=b.size()-1;

   int carry=0;
   string result="";

   while(al>=0 && bl>=0)
    {
    int temp = (int)(a[al] - '0') + (int)(b[bl] - '0') + carry ;
    carry = 0;
    if(temp > 9 )
    {
        carry=1;
        temp=temp-10;
    }

    result+=char(temp + '0');
    al--;
    bl--;
    }

   while(al>=0)
    {
        int temp = (int)(a[al] - '0') + carry ;
        carry = 0;
        if(temp>9)
        {
            carry=1;
            temp=temp%10;
        }

        result+=char(temp + '0');
        al--;
    }

   while(bl>=0)
    {
        int temp = (int)(b[bl] - '0') + carry ;
        carry = 0;
        if(temp>9)
        {
            carry=1;
            temp=temp%10;
        }

        result+=char(temp + '0');
        bl--;
    }

if(carry)
    result+="1";

string addition="";

for(int i=result.size()-1;i>=0;i--)
    addition+=result[i];   // reversing the answer

return addition;
}

string trim(string a)   // for removing leading 0s
{
   string res="";
   int i=0;

   while(a[i]=='0')
      i++;

   for(;i<a.size();i++)
    res+=a[i];

   return res;
}


int main()
{
    string a;
    string b;

    cin>>a>>b;

    cout<<trim(add(a,b))<<endl;
}

#包括
使用名称空间std；
字符串添加（字符串a、字符串b）
{
int al=a.size（）-1；
int bl=b.size（）-1；
整数进位=0；
字符串结果=”；
而（al>=0&&bl>=0）
{
int temp=（int）（a[al]-'0'）+（int）（b[bl]-'0'）+进位；
进位=0；
如果（温度>9）
{
进位=1；
温度=温度-10；
}
结果+=char（温度+'0'）；
阿尔--；
bl--；
}
而（al>=0）
{
内部温度=（内部）（a[al]-'0'）+进位；
进位=0；
如果（温度>9）
{
进位=1；
温度=温度%10；
}
结果+=char（温度+'0'）；
阿尔--；
}
而（bl>=0）
{
内部温度=（内部）（b[bl]-'0'）+进位；
进位=0；
如果（温度>9）
{
进位=1；
温度=温度%10；
}
结果+=char（温度+'0'）；
bl--；
}
如果（携带）
结果+=“1”；
字符串加法=”；
对于（int i=result.size（）-1；i>=0；i--）
加法+=结果[i]；//颠倒答案
返回加法；
}
字符串修剪（字符串a）//用于删除前导0
{
字符串res=“”；
int i=0；
而（a[i]=“0”）
i++；
对于（；i>a>>b；
CUT< P>这里是一个简单的C++代码< /P>
string Sum(string a, string b)
{
    if(a.size() < b.size())
        swap(a, b);

    int j = a.size()-1;
    for(int i=b.size()-1; i>=0; i--, j--)
        a[j]+=(b[i]-'0');

    for(int i=a.size()-1; i>0; i--)
        if(a[i] > '9')
        {
            int d = a[i]-'0';
            a[i-1] = ((a[i-1]-'0') + d/10) + '0';
            a[i] = (d%10)+'0';
        }
    if(a[0] > '9')
    {
        string k;
        k+=a[0];
        a[0] = ((a[0]-'0')%10)+'0';
        k[0] = ((k[0]-'0')/10)+'0';
        a = k+a;
    }
    return a;
}

字符串和（字符串a、字符串b）
{
如果（a.size（）=0；i--，j--）
a[j]+=（b[i]'0'）；
对于（int i=a.size（）-1；i>0；i--）
如果（a[i]>'9'）
{
int d=a[i]-“0”；
a[i-1]=（（a[i-1]-'0'）+d/10）+'0'；
a[i]=（d%10）+'0'；
}
如果（a[0]>'9'）
{
串k；
k+=a[0]；
a[0]=（（a[0]-'0'）%10）+'0'；
k[0]=（（k[0]-'0'）/10）+'0'；
a=k+a；
}
返回a；
}
引用自
回答：我写了一个更可读的代码：

void str_reverse(char *beg, char *end){
    if(!beg || !end)return;
    char cTmp;
    while(beg < end){
        cTmp = *beg;
        *beg++ = *end;
        *end-- = cTmp;
    }
}

#define c2d(c) (c - '0')
#define d2c(d) (d + '0')
void str_add(const char* s1, const char* s2, char* s_ret){
    int s1_len = strlen(s1);
    int s2_len = strlen(s2);

    int max_len = s1_len;
    int min_len = s2_len;
    const char *ps_max = s1;
    const char *ps_min = s2;

    if(s2_len > s1_len){
        ps_min = s1;min_len = s1_len;
        ps_max = s2;max_len = s2_len;
    }

    int carry = 0;
    int i, j = 0;
    for (i = max_len - 1; i >= 0; --i) {
        // this wrong-prone
        int idx = (i - max_len + min_len) >=0 ? (i - max_len + min_len) : -1;
        int sum = c2d(ps_max[i]) + (idx >=0  ? c2d(ps_min[idx]) : 0) + carry;

        carry = sum / 10;
        sum = sum % 10;

        s_ret[j++] = d2c(sum);
    }

    if(carry)s_ret[j] = '1';
    str_reverse(s_ret, s_ret + strlen(s_ret) - 1);
}

void str_reverse（char*beg，char*end）{
如果（！beg | |！end）返回；
煤焦cTmp；
while（begs1长度）{
ps_min=s1；min_len=s1_len；
ps_max=s2；max_len=s2_len；
}
整数进位=0；
int i，j=0；
对于（i=max_len-1；i>=0；--i）{
//这是一个容易出错的问题
intidx=（i-max\u len+min\u len）>=0？（i-max\u len+min\u len）：-1；
整数和=c2d（ps_max[i]）+
void str_reverse(char *beg, char *end){
    if(!beg || !end)return;
    char cTmp;
    while(beg < end){
        cTmp = *beg;
        *beg++ = *end;
        *end-- = cTmp;
    }
}

#define c2d(c) (c - '0')
#define d2c(d) (d + '0')
void str_add(const char* s1, const char* s2, char* s_ret){
    int s1_len = strlen(s1);
    int s2_len = strlen(s2);

    int max_len = s1_len;
    int min_len = s2_len;
    const char *ps_max = s1;
    const char *ps_min = s2;

    if(s2_len > s1_len){
        ps_min = s1;min_len = s1_len;
        ps_max = s2;max_len = s2_len;
    }

    int carry = 0;
    int i, j = 0;
    for (i = max_len - 1; i >= 0; --i) {
        // this wrong-prone
        int idx = (i - max_len + min_len) >=0 ? (i - max_len + min_len) : -1;
        int sum = c2d(ps_max[i]) + (idx >=0  ? c2d(ps_min[idx]) : 0) + carry;

        carry = sum / 10;
        sum = sum % 10;

        s_ret[j++] = d2c(sum);
    }

    if(carry)s_ret[j] = '1';
    str_reverse(s_ret, s_ret + strlen(s_ret) - 1);
}

void test_str_str_add(){
    char s1[] = "123";
    char s2[] = "456";
    char s3[10] = {'\0'};

    str_add(s1, s2, s3);
    std::cout<<s3<<std::endl;

    char s4[] = "456789";
    char s5[10] = {'\0'};
    str_add(s1, s4, s5);
    std::cout<<s5<<std::endl;

    char s7[] = "99999";
    char s8[] = "21";
    char s9[10] = {'\0'};
    str_add(s7, s8, s9);
    std::cout<<s9<<std::endl;
}