Question

我有一个函数调用另一个函数并检查条件以查看它是否为真，然后它递增一个整数。这一切都很好并且有效，但是对于非常大的结果会有问题。即使长时间也不适合。

示例：

unsigned long long div(int num_first[], int num_second[])
{
    unsigned long long div_result = 0;

    while (compare(num_first, num_second) != -1)
    {
        divsub(num_first, num_second);
        div_result++;
    }

    return div_result; // return div_result to main
}

该函数工作正常，但如果div_result变得太大，则会崩溃或导致未定义的行为。我想将结果存储为数组：

div_result = 25464878454

我希望它是：

div_result[max] = {2, 5, 4, 6, 4, 8, 7, 8, 4, 5, 4}

我如何实现这一目标？

修改：人们建议我决定使用unsigned long long。这适合我的情况。

Answer 1

你可以编写自己的小bigint加增量功能：

#include <iostream>

using namespace std;

const int MAXDIGITS=12;

void inc(int bignum[MAXDIGITS])
{
    ++bignum[MAXDIGITS-1];
    int carry=0;
    for(int i = MAXDIGITS-1; i>=0; --i)
    {
        bignum[i] += carry;
        if(bignum[i]>9)
        {
            carry = 1;
            bignum[i] = 0;
        }
        else
            break;
    }
}

int main()
{
    int div_result[MAXDIGITS] = {0};

    // test inc function
    for(int i=0; i<9999991; ++i)
        inc(div_result);

    for(int i=0; i<MAXDIGITS; ++i)
        cout << div_result[i];

    return 0;
}

Answer 2

自从我处理了您的原始问题以来，我会继续发布结果，以防您改变主意。可以通过多种方式处理将数字转换为数组。这是一个使用递归函数和帮助器来纠正数字顺序的方案。

注意：对于32位操作系统，由于x86使用 4位 long，使用<32位安全版本，因此会发生溢出下面包含strong> 8位 long long，最后包含使用预处理器指令集成两个版本的第3版：

#include <stdio.h>
#include <stdlib.h>

#define MAXDIG 32

void digits2array (long x, long *a, size_t *idx);
int digits2array_rev (long x, long *a, size_t *i);

int main (void) {

    long n = 25464878454;
    long ar[MAXDIG] = {0};
    size_t idx = 0;
    int i = 0;

    digits2array (n, ar, &idx);    /* convert n to array    */

    printf ("\n array:\n\n");

    for (i = 0; i < idx; i++)       /* output results       */
        printf ("   ar[%2d] : %ld\n", i, ar[i]);

    return 0;
}

/* converts x to array of digits in a (reverse order) */
int digits2array_rev (long x, long *a, size_t *i) 
{
    if (x < 10) {
        a[(*i)++] = x;
        return x;
    }

    a[(*i)++] = x % 10;

    return digits2array_rev (x / 10, a, i);
}

/* helper function to reverse results of digits2array_rev */
void digits2array (long x, long *a, size_t *idx)
{
    long tmp[MAXDIG] = {0};
    int i = 0;

    digits2array_rev (x, tmp, idx);     /* fill array with digits (reversed) */

    for (i = 0; i < *idx; i++)          /* reverse to correct order */
        a[*idx - 1 - i] = tmp[i];
}

<强>输出/结果

$ ./bin/digits2array

 array:

   ar[ 0] : 2
   ar[ 1] : 5
   ar[ 2] : 4
   ar[ 3] : 6
   ar[ 4] : 4
   ar[ 5] : 8
   ar[ 6] : 7
   ar[ 7] : 8
   ar[ 8] : 4
   ar[ 9] : 5
   ar[10] : 4

32位安全版（使用long long）

在32位操作系统上仍然会发生溢出。将类型更改为long long（x86上为8位int），允许程序在x86上运行而不会出现问题。

#include <stdio.h>
#include <stdlib.h>

#define MAXDIG 32

void digits2array (long long x, long long *a, size_t *idx);
long long digits2array_rev (long long x, long long *a, size_t *i);

int main (void) {

    long long n = 25464878454;
    long long ar[MAXDIG] = {0};
    size_t idx = 0;
    int i = 0;

    digits2array (n, ar, &idx);    /* convert n to array    */

    printf ("\n array:\n\n");

    for (i = 0; i < idx; i++)       /* output results       */
        printf ("   ar[%2d] : %lld\n", i, ar[i]);

    return 0;
}

/* converts x to array of digits in a (reverse order) */
long long digits2array_rev (long long x, long long *a, size_t *i) 
{
    if (x < 10) {
        a[(*i)++] = x;
        return x;
    }

    a[(*i)++] = x % 10;

    return digits2array_rev (x / 10, a, i);
}

/* helper function to reverse results of digits2array_rev */
void digits2array (long long x, long long *a, size_t *idx)
{
    long long tmp[MAXDIG] = {0};
    int i = 0;

    digits2array_rev (x, tmp, idx);     /* fill array with digits (reversed) */

    for (i = 0; i < *idx; i++)          /* reverse to correct order */
        a[*idx - 1 - i] = tmp[i];
}

带有预处理器指令的64/32位版本

您可以为x86完成相同的操作，同时通过使用预处理程序指令保留x86_64的原始类型。（理解实际上没有存储优势 - long（x86_64上的8位），long long（x86上的8位））。

#include <stdio.h>
#include <stdlib.h>

#if defined(__LP64__) || defined(_LP64)
# define BUILD_64   1
#endif

#define MAXDIG 32

#ifdef BUILD_64
void digits2array (long x, long *a, size_t *idx);
int digits2array_rev (long x, long *a, size_t *i);
#else
void digits2array (long long x, long long *a, size_t *idx);
long long digits2array_rev (long long x, long long *a, size_t *i);
#endif

int main (void) {

#ifdef BUILD_64
    long n = 25464878454;
    long ar[MAXDIG] = {0};
#else
    long long n = 25464878454;
    long long ar[MAXDIG] = {0};
#endif
    size_t idx = 0;
    int i = 0;

    digits2array (n, ar, &idx);    /* convert n to array    */

    printf ("\n array:\n\n");

    for (i = 0; i < idx; i++)       /* output results       */
#ifdef BUILD_64
        printf ("   ar[%2d] : %ld\n", i, ar[i]);
#else
        printf ("   ar[%2d] : %lld\n", i, ar[i]);
#endif

    return 0;
}

/* converts x to array of digits in a (reverse order) */
#ifdef BUILD_64
int digits2array_rev (long x, long *a, size_t *i)
#else
long long digits2array_rev (long long x, long long *a, size_t *i)
#endif
{
    if (x < 10) {
        a[(*i)++] = x;
        return x;
    }

    a[(*i)++] = x % 10;

    return digits2array_rev (x / 10, a, i);
}

/* helper function to reverse results of digits2array_rev */
#ifdef BUILD_64
void digits2array (long x, long *a, size_t *idx)
{
    long tmp[MAXDIG] = {0};
#else
void digits2array (long long x, long long *a, size_t *idx)
{
    long long tmp[MAXDIG] = {0};
#endif
    int i = 0;

    digits2array_rev (x, tmp, idx);     /* fill array with digits (reversed) */

    for (i = 0; i < *idx; i++)          /* reverse to correct order */
        a[*idx - 1 - i] = tmp[i];
}

将结果递增为C中的整数数组

2 个答案:

32位安全版（使用long long）

带有预处理器指令的64/32位版本