C++ C++；程序仅在打印数字时有效

我正在写一个程序，可以计算出两个大于无符号long的幂。基本上，我希望程序运行，然后在最后显示数字，但只有在每次乘以2后显示数字时，程序才起作用。以下是工作方式的代码：

#include <iostream>
#include <stdio.h>
#include <climits>

using namespace std;

class big {
public:
    short container[SHRT_MAX];
    void print() {
        digits();
        for (; length != 0; length --) {
            cout << container[length - 1];
        }
        cout << "\n";
    }
    unsigned int digits() {
        if (!length) {
            for (length = 0; ; length++) {
                if (container[length] == '\0' &&container[length + 1] == '\0' && container[length + 2] == '\0' && container[length + 3] == '\0' && container[length + 4] == '\0') break;
            }
        }
        return length;
    }
private:
    unsigned int length;
};

int numDigits(int number)
{
    int digits = 0;
    if (number < 0) digits = 1;
    while (number) {
        number /= 10;
        digits++;
    }
    return digits;
}

int main(int argc, const char * argv[])
{
    big result;
    unsigned short tempResult;
    unsigned short carry = 0;
    result.container[0] = 1;

    for (int i = 0; i < 65536; i++) {
        cout << "[" << i+1 << "]\t";
        if (i < 9) {
            cout << "\t";
        }

        carry = 0;
        unsigned int length = result.digits();
        for (int k = 0; k < length; k++) {
            tempResult = result.container[k] * 2 + carry;
            carry = 0;
            if (numDigits(tempResult) == 2) {
                carry = 1;
                result.container[k] = tempResult - 10;
                if (!result.container[k+1] && !result.container[k+2] && !result.container[k+3] && !result.container[k+4]) {
                    result.container[k+1] += carry;
                }
            }
            else {
                result.container[k] = tempResult;
            }
        }
        result.print();
    }
}

#包括
#包括
#包括
使用名称空间std；
班级大{
公众：
短容器[SHRT_MAX]；
作废打印（）{
数字（）；
对于（；长度！=0；长度--）{
cout在构造“大”对象的过程中，您的成员是默认初始化的，而不是值初始化的。因此，当您调用
digits（）
计算长度时，该数组中的任何垃圾和长度都将被当作有效的

将以下内容添加到大类中：

big() : length(0) { memset(container, 0, sizeof(container)); }

即使如此，计算结果仍存在堆栈溢出问题。这是：

if (!result.container[k+1] && !result.container[k+2] && !result.container[k+3] && !result.container[k+4]) {
    result.container[k+1] += carry;

几乎可以保证超出您的有限数字容器，使其具有足够大的
长度
（而且不会花费太多时间）

实际上，您在这个类中完成了一半的工作，一半的工作是在代码中直接修改这个类的成员。并且几乎违反了人们所能想到的所有OOP咒语。坦率地说，这非常需要重新设计

示例输出（我将其限制为128个条目）

您的
print（）
和
digits（）
只能一起工作

digits（）
仅当长度为零时才计算新的
长度。否则它什么也不做。
每次迭代时，在编写位置的
print（）
函数使
length
等于
0

当您移出打印时，
length
在下一次迭代中不等于
0
，因此长度保持不变（第一次迭代后为1）

实际上写
print（）不是一个好主意
这种方式。这意味着你只能打印一次数字。你应该使用一个局部变量。
好的，我不会说这是我的最终解决方案，因为我仍然不知道为什么会这样，但是当我将
result.length设置为0时，我可以在循环之外打印最终解决方案。下面是代码:

#include <iostream>
#include <stdio.h>
#include <climits>

using namespace std;

class big {
public:
    short container[SHRT_MAX];
    void print() {
        digits();
        for (; length != 0; length --) {
            cout << container[length - 1];
        }
        cout << "\n";
    }
    void resetLength() {
        length = 0;
    }
    unsigned int digits() {
        length = 0;
        for (length = 0; ; length++) {
            if (container[length] == '\0' &&container[length + 1] == '\0' && container[length + 2] == '\0' && container[length + 3] == '\0' && container[length + 4] == '\0') break;
        }
        return length;
    }
    big() : length(0) { memset(container, 0, sizeof(container)); }
private:
    unsigned int length;
};

int numDigits(int number)
{
    int digits = 0;
    if (number < 0) digits = 1;
    while (number) {
        number /= 10;
        digits++;
    }
    return digits;
}

int main(int argc, const char * argv[])
{
    big result;
    unsigned short tempResult;
    unsigned short carry = 0;
    result.container[0] = 1;

    for (unsigned int i = 0; i < 65536; i++) {
        /*cout << "[" << i+1 << "]\t";
        if (i < 9) {
            cout << "\t";
        }*/

        carry = 0;
        unsigned int length = result.digits();
        for (int k = 0; k < length; k++) {
            tempResult = result.container[k] * 2 + carry;
            carry = 0;
            if (numDigits(tempResult) == 2) {
                carry = 1;
                result.container[k] = tempResult - 10;
                if (!result.container[k+1] && !result.container[k+2] && !result.container[k+3] && !result.container[k+4]) {
                    result.container[k+1] += carry;
                }
            }
            else {
                result.container[k] = tempResult;
            }
        }
        result.resetLength();
    }
    result.print();
}

#包括
#包括
#包括
使用名称空间std；
班级大{
公众：
短容器[SHRT_MAX]；
作废打印（）{
数字（）；
对于（；长度！=0；长度--）{
cout
（int i=0；i<65536；i++）
使用
unsigned i
@GrijeshChauhan如果
sizeof（int）=2
就可以了，但据我所知，
sizeof（int）
应该与处理器字相同（我们这个时候至少4个），请添加插入
print（）的位置
@Alex最后我想移动result.print（）就在最后一个支架的正上方，因此它完全超出了大范围loop@GrijeshChauhan我尝试了unsigned int I，它没有改变任何东西，但是如果我的容器数组足够大，可以计算2^65536，那么它为什么会溢出？对新的组织技术有什么想法吗？@InsertNameHere，因为
length
没有初始化任何一个
#include <iostream>
#include <stdio.h>
#include <climits>

using namespace std;

class big {
public:
    short container[SHRT_MAX];
    void print() {
        digits();
        for (; length != 0; length --) {
            cout << container[length - 1];
        }
        cout << "\n";
    }
    void resetLength() {
        length = 0;
    }
    unsigned int digits() {
        length = 0;
        for (length = 0; ; length++) {
            if (container[length] == '\0' &&container[length + 1] == '\0' && container[length + 2] == '\0' && container[length + 3] == '\0' && container[length + 4] == '\0') break;
        }
        return length;
    }
    big() : length(0) { memset(container, 0, sizeof(container)); }
private:
    unsigned int length;
};

int numDigits(int number)
{
    int digits = 0;
    if (number < 0) digits = 1;
    while (number) {
        number /= 10;
        digits++;
    }
    return digits;
}

int main(int argc, const char * argv[])
{
    big result;
    unsigned short tempResult;
    unsigned short carry = 0;
    result.container[0] = 1;

    for (unsigned int i = 0; i < 65536; i++) {
        /*cout << "[" << i+1 << "]\t";
        if (i < 9) {
            cout << "\t";
        }*/

        carry = 0;
        unsigned int length = result.digits();
        for (int k = 0; k < length; k++) {
            tempResult = result.container[k] * 2 + carry;
            carry = 0;
            if (numDigits(tempResult) == 2) {
                carry = 1;
                result.container[k] = tempResult - 10;
                if (!result.container[k+1] && !result.container[k+2] && !result.container[k+3] && !result.container[k+4]) {
                    result.container[k+1] += carry;
                }
            }
            else {
                result.container[k] = tempResult;
            }
        }
        result.resetLength();
    }
    result.print();
}