安卓版c语言和c++语言输出3进制12进制62进制加法口诀表代码

于 2024-06-20 06:42:08 发布
阅读量1k 收藏 15
点赞数 12
文章标签： android c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32257509/article/details/139817622
版权

正确例题
#include <stdio.h>
#include <stdlib.h>

// 函数用于将整数转换为指定基数的字符串表示
char* intToBaseString(int num, int base) {
static char buffer[33]; // 静态数组用于存储转换后的字符串
int i = 0;
int isNegative = 0;

// 处理负数
if (num < 0) {
    isNegative = 1;
    num = -num;
}

// 转换为字符串
do {
    int digit = num % base;
    buffer[i++] = digit < 10 ? '0' + digit : 'A' + digit - 10;
    num /= base;
} while (num > 0);

// 如果是负数，添加负号
if (isNegative) {
    buffer[i++] = '-';
}

// 字符串结束符
buffer[i] = '\0';

// 反转字符串
for (int j = 0; j < i / 2; j++) {
    char temp = buffer[j];
    buffer[j] = buffer[i - j - 1];
    buffer[i - j - 1] = temp;
}

return buffer;

}

int main() {
int n, m, o;
char r[33], s[33], t[33]; // 为字符串分配足够的空间

for (n = 0; n < 8; n++) {
    for (m = 0; m < 8; m++) {
        o = n + m;
        // 调用函数将整数转换为基数为3的字符串
        strcpy(r, intToBaseString(n, 3));
        strcpy(s, intToBaseString(m, 3));
        strcpy(t, intToBaseString(o, 3));
        // 输出结果
        printf("%s+%s=%s\n", r, s, t);
    }
}

return 0;

}

将c语言进制改成c++语言的进制加法口诀表代码。
要将上述C语言代码转换为C++代码，主要需要做的是将`main`函数中的`printf`语句替换为C++的`cout`语句，并且确保使用C++的字符串处理方式。下面是转换后的C++代码：

```cpp
#include <iostream>
#include <string>
#include <algorithm> // 用于std::reverse

// 函数用于将整数转换为指定基数的字符串表示
std::string intToBaseString(int num, int base) {
    std::string buffer;
    int isNegative = 0;

    // 处理负数
    if (num < 0) {
        isNegative = 1;
        num = -num;
    }

    // 转换为字符串
    do {
        int digit = num % base;
        buffer += (digit < 10) ? ('0' + digit) : ('A' + digit - 10);
        num /= base;
    } while (num > 0);

    // 如果是负数，添加负号
    if (isNegative) {
        buffer += '-';
    }

    // 反转字符串
    std::reverse(buffer.begin(), buffer.end());

    return buffer;
}

int main() {
    int n, m, o;
    std::string r, s, t; // 使用C++的string类型

    for (n = 0; n < 8; n++) {
        for (m = 0; m < 8; m++) {
            o = n + m;
            // 调用函数将整数转换为基数为3的字符串
            r = intToBaseString(n, 3);
            s = intToBaseString(m, 3);
            t = intToBaseString(o, 3);
            // 输出结果
            std::cout << r << "+" << s << "=" << t << std::endl;
        }
    }

    return 0;
}

主要改动点：

  1. 包含了<iostream>和<string>头文件，以使用C++的输入输出流和字符串类。
  2. intToBaseString函数返回类型从char*改为std::string。
  3. main函数中使用std::string类型来存储转换后的字符串。
  4. 使用std::cout和std::endl来输出结果。
  5. 使用std::reverse函数来反转字符串，代替了C语言中的手动反转。

注意：在C++中，使用std::string和std::reverse是更符合C++风格的做法，因为它们提供了更安全、更易于使用的字符串处理方式。

正确例题
#include <stdio.h>
#include <stdlib.h>

// 函数用于将整数转换为指定基数的字符串表示
char* intToBaseString(int num, int base) {
static char buffer[33]; // 静态数组用于存储转换后的字符串
int i = 0;
int isNegative = 0;

// 处理负数
if (num < 0) {
    isNegative = 1;
    num = -num;
}

// 转换为字符串
do {
    int digit = num % base;
    buffer[i++] = digit < 10 ? '0' + digit : 'A' + digit - 10;
    num /= base;
} while (num > 0);

// 如果是负数，添加负号
if (isNegative) {
    buffer[i++] = '-';
}

// 字符串结束符
buffer[i] = '\0';

// 反转字符串
for (int j = 0; j < i / 2; j++) {
    char temp = buffer[j];
    buffer[j] = buffer[i - j - 1];
    buffer[i - j - 1] = temp;
}

return buffer;

}

int main() {
int n, m, o;
char r[33], s[33], t[33]; // 为字符串分配足够的空间

for (n = 0; n < 8; n++) {
    for (m = 0; m < 8; m++) {
        o = n + m;
        // 调用函数将整数转换为基数为3的字符串
        strcpy(r, intToBaseString(n, 4));
        strcpy(s, intToBaseString(m, 4));
        strcpy(t, intToBaseString(o, 4));
        // 输出结果
        printf("%s+%s=%s\n", r, s, t);
    }
}

return 0;

}
将c语言4进制改成c++语言的4进制加法口诀表代码。
要将上述C语言代码转换为C++代码，并且将4进制改为C++风格的4进制加法口诀表，我们需要做以下几点改动：

  1. 将main函数中的printf替换为C++的cout。
  2. 使用C++的std::string来处理字符串，而不是C语言的字符数组。
  3. 由于C++中没有strcpy函数，我们将使用std::strcpy（如果使用C++11或更高版本，可以使用std::strcpy_s）。
  4. 由于C++中没有<stdio.h>和<stdlib.h>，我们将使用C++的头文件<cstdio>和<cstdlib>。

下面是转换后的C++代码：

#include <iostream>
#include <cstring> // C++中包含cstring头文件来使用strcpy
#include <cstdlib> // C++中包含cstdlib头文件来使用atoi

// 函数用于将整数转换为指定基数的字符串表示
std::string intToBaseString(int num, int base) {
    static char buffer[33]; // 静态数组用于存储转换后的字符串
    int i = 0;
    int isNegative = 0;

    // 处理负数
    if (num < 0) {
        isNegative = 1;
        num = -num;
    }

    // 转换为字符串
    do {
        int digit = num % base;
        buffer[i++] = digit < 10 ? '0' + digit : 'A' + digit - 10;
        num /= base;
    } while (num > 0);

    // 如果是负数，添加负号
    if (isNegative) {
        buffer[i++] = '-';
    }

    // 字符串结束符
    buffer[i] = '\0';

    // 反转字符串
    for (int j = 0; j < i / 2; j++) {
        char temp = buffer[j];
        buffer[j] = buffer[i - j - 1];
        buffer[i - j - 1] = temp;
    }

    return std::string(buffer); // 返回std::string类型
}

int main() {
    int n, m, o;
    std::string r, s, t; // 使用C++的string类型

    for (n = 0; n < 8; n++) {
        for (m = 0; m < 8; m++) {
            o = n + m;
            // 调用函数将整数转换为基数为4的字符串
            r = intToBaseString(n, 4);
            s = intToBaseString(m, 4);
            t = intToBaseString(o, 4);
            // 输出结果
            std::cout << r << "+" << s << "=" << t << std::endl;
        }
    }

    return 0;
}

注意：在C++中，我们使用std::string来处理字符串，这样可以避免手动管理内存和处理字符串结束符。同时，我们使用std::strcpy来复制字符串，这在C++中是安全的，因为std::string提供了必要的操作。此外，我们使用std::cout来输出结果，这是C++中标准的输出方式。

正确例题
#include <stdio.h>
#include <stdlib.h>

// 函数用于将整数转换为指定基数的字符串表示
char* intToBaseString(int num, int base) {
static char buffer[33]; // 静态数组用于存储转换后的字符串
int i = 0;
int isNegative = 0;

// 处理负数
if (num < 0) {
    isNegative = 1;
    num = -num;
}

// 转换为字符串
do {
    int digit = num % base;
    if (digit < 10) {
        buffer[i++] = '0' + digit; // 0-9
    } else {
        buffer[i++] = 'A' + digit - 10; // A表示10，B表示11
    }
    num /= base;
} while (num > 0);

// 如果是负数，添加负号
if (isNegative) {
    buffer[i++] = '-';
}

// 字符串结束符
buffer[i] = '\0';

// 反转字符串
for (int j = 0; j < i / 2; j++) {
    char temp = buffer[j];
    buffer[j] = buffer[i - j - 1];
    buffer[i - j - 1] = temp;
}

return buffer;

}

int main() {
int n, m, o;
char r[33], s[33], t[33]; // 为字符串分配足够的空间

// 生成12进制加法口诀表
for (n = 0; n < 12; n++) {
    for (m = 0; m < 12; m++) {
        o = n + m;
        // 调用函数将整数转换为基数为12的字符串
        strcpy(r, intToBaseString(n, 12));
        strcpy(s, intToBaseString(m, 12));
        strcpy(t, intToBaseString(o, 12));
        // 输出结果
        printf("%s+%s=%s\n", r, s, t);
    }
    printf("\n"); // 每完成一行后换行
}

return 0;

}

将c语言12进制改成c++语言的12进制加法口诀表代码。
要将上述C语言代码转换为C++代码，并且生成12进制加法口诀表，我们需要进行以下改动：

1. 将`main`函数中的`printf`替换为C++的`cout`。
2. 使用C++的`std::string`来处理字符串，而不是C语言的字符数组。
3. 由于C++中没有`<stdio.h>`和`<stdlib.h>`，我们将使用C++的头文件`<cstdio>`和`<cstdlib>`。
4. 由于C++中没有`strcpy`函数，我们将使用`std::strcpy`（如果使用C++11或更高版本，可以使用`std::strcpy_s`）。

下面是转换后的C++代码：

```cpp
#include <iostream>
#include <cstring> // C++中包含cstring头文件来使用strcpy
#include <cstdlib> // C++中包含cstdlib头文件来使用atoi

// 函数用于将整数转换为指定基数的字符串表示
std::string intToBaseString(int num, int base) {
    static char buffer[33]; // 静态数组用于存储转换后的字符串
    int i = 0;
    int isNegative = 0;

    // 处理负数
    if (num < 0) {
        isNegative = 1;
        num = -num;
    }

    // 转换为字符串
    do {
        int digit = num % base;
        if (digit < 10) {
            buffer[i++] = '0' + digit; // 0-9
        } else {
            buffer[i++] = 'A' + digit - 10; // A表示10，B表示11
        }
        num /= base;
    } while (num > 0);

    // 如果是负数，添加负号
    if (isNegative) {
        buffer[i++] = '-';
    }

    // 字符串结束符
    buffer[i] = '\0';

    // 反转字符串
    for (int j = 0; j < i / 2; j++) {
        char temp = buffer[j];
        buffer[j] = buffer[i - j - 1];
        buffer[i - j - 1] = temp;
    }

    return std::string(buffer); // 返回std::string类型
}

int main() {
    int n, m, o;
    std::string r, s, t; // 使用C++的string类型

    // 生成12进制加法口诀表
    for (n = 0; n < 12; n++) {
        for (m = 0; m < 12; m++) {
            o = n + m;
            // 调用函数将整数转换为基数为12的字符串
            r = intToBaseString(n, 12);
            s = intToBaseString(m, 12);
            t = intToBaseString(o, 12);
            // 输出结果
            std::cout << r << "+" << s << "=" << t << std::endl;
        }
        std::cout << std::endl; // 每完成一行后换行
    }

    return 0;
}

注意：在C++中，我们使用std::string来处理字符串，这样可以避免手动管理内存和处理字符串结束符。同时，我们使用std::cout来输出结果，这是C++中标准的输出方式。此外，我们使用std::strcpy来复制字符串，这在C++中是安全的，因为std::string提供了必要的操作。

正确例题
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 函数用于将整数转换为指定基数的字符串表示
char* intToBaseString(int num, int base) {
static char buffer[65]; // 静态数组用于存储转换后的字符串
int i = 0;
int isNegative = 0;

// 处理负数
if (num < 0) {
    isNegative = 1;
    num = -num;
}

// 转换为字符串
do {
    int digit = num % base;
    if (digit < 10) {
        buffer[i++] = '0' + digit; // 0-9
    } else if (digit < 36) {
        buffer[i++] = 'A' + digit - 10; // A-Z
    } else {
        buffer[i++] = 'a' + digit - 36; // a-z
    }
    num /= base;
} while (num > 0);

// 如果是负数，添加负号
if (isNegative) {
    buffer[i++] = '-';
}

// 字符串结束符
buffer[i] = '\0';

// 反转字符串
for (int j = 0; j < i / 2; j++) {
    char temp = buffer[j];
    buffer[j] = buffer[i - j - 1];
    buffer[i - j - 1] = temp;
}

return buffer;

}

int main() {
int n, m, o;
char r[65], s[65], t[65]; // 为字符串分配足够的空间

// 生成36进制加法口诀表
for (n = 0; n < 36; n++) {
    for (m = 0; m < 36; m++) {
        o = n + m;
        // 调用函数将整数转换为基数为36的字符串
        strcpy(r, intToBaseString(n, 36));
        strcpy(s, intToBaseString(m, 36));
        strcpy(t, intToBaseString(o, 36));
        // 输出结果
        printf("%s+%s=%s\n", r, s, t);
    }
    printf("\n"); // 每完成一行后换行
}

return 0;

}
将c语言36进制改成c++语言的36进制加法口诀表代码。
下面是将上述C语言代码转换为C++代码的版本，用于生成36进制加法口诀表：

#include <iostream>
#include <string>
#include <algorithm> // 用于std::reverse

// 函数用于将整数转换为指定基数的字符串表示
std::string intToBaseString(int num, int base) {
    std::string buffer;
    int isNegative = 0;

    // 处理负数
    if (num < 0) {
        isNegative = 1;
        num = -num;
    }

    // 转换为字符串
    do {
        int digit = num % base;
        if (digit < 10) {
            buffer += '0' + digit; // 0-9
        } else if (digit < 36) {
            buffer += 'A' + digit - 10; // A-Z
        } else {
            buffer += 'a' + digit - 36; // a-z
        }
        num /= base;
    } while (num > 0);

    // 如果是负数，添加负号
    if (isNegative) {
        buffer += '-';
    }

    // 反转字符串
    std::reverse(buffer.begin(), buffer.end());

    return buffer;
}

int main() {
    int n, m, o;
    std::string r, s, t; // 使用C++的string类型

    // 生成36进制加法口诀表
    for (n = 0; n < 36; n++) {
        for (m = 0; m < 36; m++) {
            o = n + m;
            // 调用函数将整数转换为基数为36的字符串
            r = intToBaseString(n, 36);
            s = intToBaseString(m, 36);
            t = intToBaseString(o, 36);
            // 输出结果
            std::cout << r << "+" << s << "=" << t << std::endl;
        }
        std::cout << std::endl; // 每完成一行后换行
    }

    return 0;
}

主要改动点：

  1. 移除了<stdio.h>和<stdlib.h>，因为C++中使用<iostream>和<cstdlib>。
  2. 移除了<string.h>，因为C++中使用<cstring>。
  3. 将char*返回类型改为std::string。
  4. 使用std::string的+=操作符来构建字符串，而不是使用字符数组和strcpy。
  5. 使用std::reverse来反转字符串，而不是手动交换字符。
  6. 使用std::cout来输出结果，这是C++中标准的输出方式。

注意：在C++中，std::string提供了方便的字符串操作方法，包括字符串的拼接、反转等，因此在处理字符串时，使用std::string通常比使用字符数组更为方便和安全。

正确例题
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 函数用于将整数转换为指定基数的字符串表示
char* intToBaseString(int num, int base) {
    static char buffer[65]; // 静态数组用于存储转换后的字符串
    int i = 0;
    int isNegative = 0;

    // 处理负数
    if (num < 0) {
        isNegative = 1;
        num = -num;
    }

    // 转换为字符串
    do {
        int digit = num % base;
        if (digit < 10) {
            buffer[i++] = '0' + digit; // 0-9
        } else if (digit < 36) {
            buffer[i++] = 'A' + digit - 10; // A-Z
        } else {
            buffer[i++] = 'a' + digit - 36; // a-z
        }
        num /= base;
    } while (num > 0);

    // 如果是负数，添加负号
    if (isNegative) {
        buffer[i++] = '-';
    }

    // 字符串结束符
    buffer[i] = '\0';

    // 反转字符串
    for (int j = 0; j < i / 2; j++) {
        char temp = buffer[j];
        buffer[j] = buffer[i - j - 1];
        buffer[i - j - 1] = temp;
    }

    return buffer;
}

int main() {
    int n, m, o;
    char r[65], s[65], t[65]; // 为字符串分配足够的空间

    // 生成62进制加法口诀表
    for (n = 0; n < 62; n++) {
        for (m = 0; m < 62; m++) {
            o = n + m;
            // 调用函数将整数转换为基数为62的字符串
            strcpy(r, intToBaseString(n, 62));
            strcpy(s, intToBaseString(m, 62));
            strcpy(t, intToBaseString(o, 62));
            // 输出结果
            printf("%s+%s=%s\n", r, s, t);
        }
        printf("\n"); // 每完成一行后换行
    }

    return 0;
}

将c语言62进制改成c++语言的62进制加法口诀表代码。
下面是将上述C语言代码转换为C++代码的版本，用于生成62进制加法口诀表：

#include <iostream>
#include <string>
#include <algorithm> // 用于std::reverse

// 函数用于将整数转换为指定基数的字符串表示
std::string intToBaseString(int num, int base) {
    std::string buffer;
    int isNegative = 0;

    // 处理负数
    if (num < 0) {
        isNegative = 1;
        num = -num;
    }

    // 转换为字符串
    do {
        int digit = num % base;
        if (digit < 10) {
            buffer += '0' + digit; // 0-9
        } else if (digit < 36) {
            buffer += 'A' + digit - 10; // A-Z
        } else {
            buffer += 'a' + digit - 36; // a-z
        }
        num /= base;
    } while (num > 0);

    // 如果是负数，添加负号
    if (isNegative) {
        buffer += '-';
    }

    // 反转字符串
    std::reverse(buffer.begin(), buffer.end());

    return buffer;
}

int main() {
    int n, m, o;
    std::string r, s, t; // 使用C++的string类型

    // 生成62进制加法口诀表
    for (n = 0; n < 62; n++) {
        for (m = 0; m < 62; m++) {
            o = n + m;
            // 调用函数将整数转换为基数为62的字符串
            r = intToBaseString(n, 62);
            s = intToBaseString(m, 62);
            t = intToBaseString(o, 62);
            // 输出结果
            std::cout << r << "+" << s << "=" << t << std::endl;
        }
        std::cout << std::endl; // 每完成一行后换行
    }

    return 0;
}

主要改动点：

  1. 移除了<stdio.h>和<stdlib.h>，因为C++中使用<iostream>和<cstdlib>。
  2. 移除了<string.h>，因为C++中使用<cstring>。
  3. 将char*返回类型改为std::string。
  4. 使用std::string的+=操作符来构建字符串，而不是使用字符数组和strcpy。
  5. 使用std::reverse来反转字符串，而不是手动交换字符。
  6. 使用std::cout来输出结果，这是C++中标准的输出方式。

注意：在C++中，std::string提供了方便的字符串操作方法，包括字符串的拼接、反转等，因此在处理字符串时，使用std::string通常比使用字符数组更为方便和安全。

EYYLTV
关注
  • 12
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

EYYLTV

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值