Flattened Int array C++（每个整数的结尾都被错误地翻译了）

Question

有一个整数数组，我想将它们转换成一个由分隔的数字组成的数组，然后将它们作为相同的整数集打印出来。

ps: 原因是，我想做很多单个数字的计算，我想用这种方法来分离数字，并存储它们的“分离索引”，将它们转回不同的整数之后。

但是，有一个问题，几乎所有的数字都被正确翻译了，但在每一端都有一些是错误的。

代码：

#include <iostream>

using std::cout; using std::endl;

int* charArrToIntArray(char** input, int* sizeofnumbers, int sizeofarray) {
    int* output = new int[100];
    cout << input[0][0] << endl;
    cout << sizeofnumbers[0] << endl;
    cout << sizeofarray << endl;
    for (int counter = 0; counter < sizeofarray; counter++) {
        int i;
        sscanf_s(input[counter], "%d", &i);
        output[counter] = i;
    }
    return output;
}

int* intToIntArray(int input, int length) {
    static int output[20];
    for (int i = 0; i < length; i++) {
        output[i] = input % 10;
        input /= 10;
    }
    return output;
}

int main()
{
    const int arraySize = 5;
    int NumSize[arraySize] = { 6, 7, 5, 9, 8 };
    int NumSizeFlatten[arraySize + 1] = { 0 };
    static int IntArray[arraySize] = {345678, 6543210, 11101, 110010001, 00011100};
    static int arr2D[500]; //The flat 2D array...
    for (int counter = 0; counter < arraySize; counter++) {
        int* arr1D = intToIntArray(IntArray[counter], NumSize[counter]);

        for (int i = 0; i <= counter; i++) {
            NumSizeFlatten[counter + 1] += NumSize[i]; //Get the values of positions of flattened array's separation points
        }

        for (int i = NumSize[counter] - 1; i >= 0; i--) {
            printf("%d", arr1D[i]); //Directly Print from the arrays
        }printf("\n");

        for (int i = 0; i < NumSize[counter]; i++) {
            arr2D[NumSizeFlatten[counter] + i - 1] = arr1D[NumSize[counter] - i]; //PUT arrays into a Flattened array //warning C6386: buffer overrun
        }
    }

    for (int i = 0; i < 50; i++) {
        printf("%d", arr2D[i]); //Directly print the Flattened array in a flattened from.
    }

    for (int j = 1; j <= arraySize; j++) {
        printf("NumSizeFlatten[%d] = %d\n", j, NumSizeFlatten[j]); //Print the values of positions of flattened array's separation points
    }

    for (int i = 0; i < arraySize; i++) {
        for (int j = NumSizeFlatten[i]; j < NumSizeFlatten[i + 1]; j++) {
            //printf("%d.", j);
            printf("%d", arr2D[j]); //Print From the Flattened Array
        }printf("\n");
    }
}

输出：

345678
6543210
11101
110010001
00004672
34567065432151110011001000100004670000000000000000NumSizeFlatten[1] = 6
NumSizeFlatten[2] = 13
NumSizeFlatten[3] = 18
NumSizeFlatten[4] = 27
NumSizeFlatten[5] = 35
345670
6543215
11100
110010001
00004670

最后一个整数也是错误的。

我知道这段代码真的很垃圾，我正在尽我所能...

Answer 1

你会使用STL数据结构和算法吗？

这是一些代码：

从整数向量开始。
从中创建一个字符串向量。
将字符串向量展平为 int 数字向量。
将字符串向量转换回整数向量。

[Demo]

#include <algorithm>  // for_each, transform
#include <fmt/ranges.h>
#include <sstream>  // ostringstream
#include <string>  // to_string
#include <vector>

#include "range/v3/all.hpp"

int main()
{
    // Ints
    const std::vector<int> vi{345678, 6543210, 11101, 110010001, 00011100};
    fmt::print("vi = {}\n", vi);

    // Ints to strings
    std::vector<std::string> vs{};
    std::ranges::transform(vi, std::back_inserter(vs), [](int i) {
        return std::to_string(i);
    });
    fmt::print("vs = {}\n", vs);

    // Strings to flat ints
    std::vector<int> flat_vi{};
    std::ranges::for_each(vs, [&flat_vi](const auto& s) {
        std::ranges::transform(s, std::back_inserter(flat_vi), [](unsigned char c){
            return c - '0';
        });
    });
    fmt::print("flat_vi = {}\n", flat_vi);

    // Strings to flat ints (using ranges)
    auto flat_vi_2 = vs
        | ranges::view::join
        | ranges::view::transform([](unsigned char c) { return c - '0'; })
        | ranges::to_vector;
    fmt::print("flat_vi_2 = {}\n", flat_vi_2);
    
    // Strings back to ints
    std::vector<int> vo{};
    std::ranges::transform(vs, std::back_inserter(vo), [](const auto& s){
        return std::atoi(s.c_str());
    });
    fmt::print("vo = {}\n", vo);
}

// Outputs:
//
//   vi = [345678, 6543210, 11101, 110010001, 4672]
//   vs = ["345678", "6543210", "11101", "110010001", "4672"]
//   flat_vi = [3, 4, 5, 6, 7, 8, 6, 5, 4, 3, 2, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 4, 6, 7, 2]
//   flat_vi_2 = [3, 4, 5, 6, 7, 8, 6, 5, 4, 3, 2, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 4, 6, 7, 2]
//   vo = [345678, 6543210, 11101, 110010001, 4672]

在您发表评论后更新我的回答。

您可能仍然可以在 std::vector 等数据结构上完成大部分工作，然后传递一个 int 数字数组。
这是一个非常不推荐的做法，因为您必须注意不要在其他代码对其数据进行操作时修改 std::vector。否则，您将得到未定义的行为（基本上，修改可能会导致内容重定位，因此指向这些内容的指针将不再有效）。
此外，如果您考虑并行执行代码，请注意许多 STL 算法已经提供了该功能。例如。检查 std::transform's overloads using an ExecutionPolicy.

[Demo]

#include <span>

void operate_on_flat_vector_data(int* data, size_t size)
{
    std::cout << "flat_vi.data() = [";
    bool first{true};
    for (size_t i{0}; i < size; ++i) {
        std::cout << (first ? "" : ", ") << data[i];
        first = false;
    }
    std::cout << "]\n";
}

void operate_on_flat_vector_data(std::span<const int> data)
{
    std::cout << "flat_vi.data() = [";
    bool first{true};
    for (const int i : data) {
        std::cout << (first ? "" : ", ") << i;
        first = false;
    }
    std::cout << "]\n";
}

int main()
{
    // Passing flat vector's data around
    operate_on_flat_vector_data(flat_vi.data(), flat_vi.size());

    // Passing flat vector's data around (using span)
    operate_on_flat_vector_data({flat_vi.data(), flat_vi.size()});
}

Flattened Int array C++（每个整数的结尾都被错误地翻译了）

Flattened Int array C++ (the ends of each integer is translated wrongly)

c++

arrays

integer

flatten