1018: A+B again

本文介绍了一种使用栈来处理大数加法的方法。针对传统32位整数处理大数的局限性,该算法通过字符串输入表示任意大小的整数,并确保计算正确性。文章详细展示了算法流程及其实现细节。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 

1018: A+B again

 

  • 题目描述:

谷学长有一个非常简单的问题给你,给你两个整数A和B,你的任务是计算A+B。

  • 输入:

输入的第一行包含一个整数T(T<=20)表示测试实例的个数,然后2*T行,分别表示A和B两个正整数。注意整数非常大,那意味着你不能用32位整数来处理。你可以确定的是整数的长度不超过1000。

  • 输出:

对于每一个样例,你应该输出两行,第一行是"Case #:",#表示第几个样例,第二行是一个等式"A+B=Sum",Sum表示A+B的结果。注意等式中有空格。

  • 样例输入

2
1
2
112233445566778899
998877665544332211
  • 样例输出

Case 1:
1 + 2 = 3
Case 2:
112233445566778899 + 998877665544332211 = 1111111111111111110
#include<iostream>
#include <stack>
#include <stdlib.h>
#include <stack>
#include <cstring>
using namespace std;

int main()
{
    stack <int> n1;
    stack <int> n2;
    stack <int> sum;
    string str1,str2;
    char c1;
    char c2;
    int T;
    cin>>T;
    int carryTrans = 0;
    for (int i = 0; i < T; ++i) {
        cin >> str1;
        cin >> str2;
        if (str1.length() != str2.length()) {                        //如果长度不一致,首先进行等长处理
            if (str1.length() > str2.length()) {
                int temp1 = str1.length() - str2.length();
                for (int j = 0; j < temp1; ++j) {
                    char temp = '0';
                    int atoi(temp);
                    n2.push(temp - 48);
                }
            } else {
                int temp2 = str2.length() - str1.length();
                for (int j = 0; j < temp2; ++j) {
                    char temp = '0';
                    int atoi(temp);
                    n1.push(temp - 48);
                }
            }
        }
        for (int j1 = 0; j1 < str1.length(); ++j1) {
            char temp = str1[j1];
            int atoi(temp);
            n1.push(temp - 48);
        }
        for (int j2 = 0; j2 < str2.length(); ++j2) {
            char temp = str2[j2];
            int atoi(temp);
            n2.push(temp - 48);
        }
        int T2;
        if (str1.length() > str2.length()) {
            T2 = str1.length();
        } else {
            T2 = str2.length();
        }
        for (int k = 0; k < T2; k++) {
            int temp = n1.top() + n2.top() + carryTrans;
            if (temp >= 10) {
                temp = temp - 10;
                carryTrans = 1;
            }
            else{
                carryTrans = 0;
            }
            sum.push(temp);
            n1.pop();
            n2.pop();
        }
        if (carryTrans == 1){
            sum.push(1);
        }
        cout<<"Case "<<i+1<<":"<<endl;
        cout<<str1<<" + ";
        cout<<str2<<" = ";
        while (!sum.empty()) {
            cout << sum.top();
            sum.pop();
        }
        cout << endl;
    }
    return 0;
}

用了栈来储存数据,比起char数组可以按照数据的产犊来分配内存,而且之后的相加、输出都比较方便。

<think>我们首先需要分析用户的问题。用户给出了一个关于C语言指针字符串操作的代码行为的问题,但并没有提供具体的代码片段。不过,用户提到了“分析给定代码片段中指针赋值字符串修改后的输出结果”,并提供了几个引用。回顾之前的对话历史,用户最初的问题是关于指针数组的赋值正确性(题目有四个选项)。现在用户转向了字符串指针的输出结果分析。由于用户没有提供具体的代码,我假设用户可能希望我根据引用内容来解释常见的字符串与指针操作,并分析一些典型代码的输出。引用[1]展示了字符数组字符指针都可以用来处理字符串,并给出了一个printf输出的例子。引用[2]展示了通过指针偏移量遍历字符串常量的方法。引用[3]展示了指针数组指向指针的指针的使用。引用[4]则强调了字符数组字符指针在内存分配上的区别:字符数组有确定的内存地址,而字符指针如果未初始化则指向不确定。结合用户的问题,我猜测用户可能想了解以下内容:1.字符数组字符指针的区别。2.字符串常量的修改问题(是否合法)。3.指针操作字符串时的输出行为。因此,我将设计一个典型的代码片段,并分析其输出。注意:用户提到“字符串修改后的输出结果”,所以我会包含尝试修改字符串的情况,以展示未定义行为。下面是一个示例代码片段:```c#include<stdio.h>intmain(){charstr1[]="Hello";//字符数组char*str2="World";//字符指针指向字符串常量//尝试修改str1[0]='h';//合法,因为str1是数组,存储在自己的空间//str2[0]='w';//非法,字符串常量不可修改,运行时会出错printf("str1:%s\n",str1);//输出:helloprintf("str2:%s\n",str2);//输出:World//另一个常见问题:指针指向数组后修改char*str3=str1;str3[0]='H';//合法,因为str3指向的是可修改的数组printf("str1again:%s\n",str1);//输出:Hello//指向指针的指针char*arr[]={str1,str2};//指针数组char**p=arr;//指向指针的指针printf("arr[0]:%s\n",arr[0]);//输出:Helloprintf("arr[1]:%s\n",arr[1]);//输出:Worldprintf("p[0]:%s\n",p[0]);//输出:Helloprintf("p[1]:%s\n",p[1]);//输出:Worldreturn0;}```###分析:1.`str1`是一个字符数组,初始化为"Hello",它拥有自己的存储空间,因此可以修改其内容。将第一个字符改为'h'后,输出为"hello"。2.`str2`是一个字符指针,指向字符串常量"World"。在C语言中,字符串常量存储在只读内存区域,尝试修改(如`str2[0]='w'`)会导致未定义行为(通常程序崩溃)。所以注释掉了这行。3.将`str3`指向`str1`(即可修改的数组),然后通过`str3`修改第一个字符为'H',这样`str1`就变回了"Hello"。4.指针数组`arr`包含两个元素:`str1``str2`(即分别指向可修改数组字符串常量)。然后使用指向指针的指针`p`(初始指向`arr`)来访问这两个字符串。输出结果:```str1:hellostr2:Worldstr1again:Helloarr[0]:Helloarr[1]:Worldp[0]:Hellop[1]:World```注意:在输出中,`str1`首先被修改为"hello",然后又被修改回"Hello"(通过`str3`),所以最后输出的是"Hello"。###重要注意事项:-字符指针指向字符串常量时,不能通过该指针修改字符串内容,否则会导致未定义行为。-字符数组(如`charstr[]="string";`)中的内容可以修改,因为数组会复制字符串常量到自己的存储空间(在栈上)。###相关问题:1.为什么修改字符指针指向的字符串常量会导致程序崩溃?2.字符数组字符指针在内存分配上有何本质区别?3.如何安全地使用字符指针处理字符串?4.指针数组指向指针的指针在字符串处理中有什么应用场景?以上内容基于引用[1][4]中关于字符数组字符指针的区别[^1][^4],以及引用[3]中关于指针数组指向指针的指针的使用[^3]。</think>### C语言指针与字符串操作分析 #### 核心概念解析 1. **字符数组 vs 字符指针** - 字符数组 `char sa[] = "array"`: 在栈空间分配内存,内容可修改,数组名 `sa` 是首元素地址常量(类型 `char* const`)[^1][^4] - 字符指针 `char* sp = "point"`: 指针变量存储字符串常量首地址,字符串常量位于只读数据段(.rodata),**不可修改**[^1][^4] 2. **指针操作字符串** - 通过偏移量访问:`*(pstr+i)` 等价于 `pstr[i]`[^2] - 指针数组处理:`int* n[5]` 存储多个指针,可通过二级指针 `int** p = n` 访问[^3] #### 典型代码行为分析 ```c #include <stdio.h> int main() { // 场景1: 字符数组修改 char sa[] = "Hello"; sa[0] = 'h'; // ✅ 合法修改 printf("sa: %s\n", sa); // 输出: hello // 场景2: 字符指针修改尝试 char* sp = "World"; // sp[0] = 'w'; // ❌ 运行时错误!尝试修改只读内存 // 场景3: 指针偏移访问 const char* pstr = "Pointer"; for(int i=0; i<3; i++) printf("%c", pstr[i]); // 输出: Poi printf("\n"); // 场景4: 指针数组与二级指针 int a[3] = {10,20,30}; int* q[3] = {&a[0], &a[1], &a[2]}; int** pp = q; printf("%d\n", **pp); // 输出: 10 pp++; printf("%d\n", **pp); // 输出: 20 return 0; } ``` #### 关键结论 1. **修改权限** - 字符数组内容可安全修改(栈内存) - 字符指针指向的字符串常量**不可修改**(只读段),尝试修改导致未定义行为[^4] 2. **输出机制** `printf("%s", ptr)` 会从指针位置开始输出,直到遇到 `\0` 结束符[^1] 3. **指针运算本质** `p[i]` 等价于 `*(p+i)`,编译器自动计算字节偏移量(`i * sizeof(type)`)[^2] 4. **二级指针访问** 对指针数组使用 `int** pp = q` 时: - `*pp` 获取指针元素地址 - `**pp` 解引用获取实际值[^3] #### 内存模型示意图 ``` 只读数据段(.rodata) 栈空间(stack) 指针变量 ┌───────────────┐ ┌──────────────┐ ┌───────┐ │ "World"常量 │←──────┼ char* sp │ │ int** pp ├───────────────┤ ├──────────────┤ └───┬───┘ │ "Pointer"常量 │←────┐ │ char sa[] │ ↓ └───────────────┘ │ │ h e l l o \0│ ┌───┴───┐ └─┼ const char* pstr │ q[0]─┼→a[0] └──────────────┘ │ q[1]─┼→a[1] │ q[2]─┼→a[2] └──────┘ ``` ### 相关问题 1. 为什么字符指针指向的字符串常量不可修改?如何检测这类错误? 2. 指针数组二维数组在内存布局上有何本质区别? 3. `char str[] = "text"` `char* str = "text"` 的初始化过程有何不同? 4. 二级指针在动态内存分配中如何正确使用? 5. 如何通过指针操作实现字符串的拼接比较函数?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值