将 int 数组从零填充到定义的数字

Question

我需要将 C++ 中的 int[] 数组从零填充到由变量定义的数字，但 ISO C++ 禁止变长数组... 如何轻松填充数组？我需要分配/释放内存吗？

int possibilities[SIZE];
unsigned int i = 0;
for (i = 0; i < SIZE; i++) {
    possibilities[i] = i;
}

顺便说一句。如果您要问 - 是的，我需要完全标准的 int[] 数组，没有向量，没有地图等。

Answer 1

在 c++11 中，您可以使用 std::iota 和 std::array。下面的示例使用 1 到 10 的值填充大小为 10 的数组。

std::array<int, 10> a;
std::iota(a.begin(), a.end(), 1);

编辑 自然 std::iota 也适用于向量。

Answer 2

正如您所发现的，您不能在堆栈上创建可变长度数组。因此，您的选择是在堆上分配它（引入内存管理问题），或者使用 std::vector 而不是 C 样式数组：

std::vector<int> possibilities(SIZE);
for (int i = 0; i < SIZE; i++)
{
    possibilities[i] = i;
}

如果你想变得更加华丽，你可以使用 STL 为你生成这个序列：

// This is a "functor", a class object that acts like a function with state
class IncrementingSequence
{
public:
    // Constructor, just set counter to 0
    IncrementingSequence() : i_(0) {}
    // Return an incrementing number
    int operator() () { return i_++; }
private:
    int i_;
}

std::vector<int> possibilities(SIZE);
// This calls IncrementingSequence::operator() for each element in the vector,
// and assigns the result to the element
std::generate(possibilities.begin(), possibilities.end(), IncrementingSequence);

Answer 3

如果您可以访问 boost，那么您已经可以访问递增迭代器。

#include <vector>
#include <boost/iterator/counting_iterator.hpp>

std::vector<int> possibilities(
    boost::counting_iterator<int>(0),
    boost::counting_iterator<int>(SIZE));

counting iterator 本质上包含了递增值。所以你可以自动告诉它开始和结束的值和向量会正确地填充自己。

正如在别处提到的，结果向量可以直接与 std::next_permutation 一起使用。

std::next_permutation(possibilities.begin(),possibilities.end());

Answer 4

std::vector<int> possibilities;
unsigned int i = 0;
for (i = 0; i < SIZE; i++) {
    possibilities.push_back(i);
}

使用std::vector（需要包含<vector>）

如果你想将向量传递给std::next_permutation，你需要写：

std::next_permutation(possibilities.begin(),possibilities.end());

您也可以将向量用作 C 样式数组。 &vec[0] 返回指向 C 样式数组的指针。

Answer 5

你可以使用std::generate_n函数：

std::generate_n( myarray, SIZE, increment() );

其中increment 是一个生成数字的对象：

struct increment {
 int value;
 int operator() () { return ++value; }
 increment():value(0){}
};

Answer 6

如果您将 SIZE 设为常量（宏或const），您可以使用它来指定静态数组的大小。如果无法使用常量，例如您正在从程序外部读取预期大小，那么是的，您需要分配内存。

简而言之，如果您在编译时不知道大小，您可能需要在运行时分配内存。

Answer 7

std::generate() 可以与可变 lambda 函数一起使用以更简洁。以下 C++ sn-p 会将值 0..9 （含）放入大小为 10 的向量 A 中，并将这些值打印在单行输出中：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    size_t N = 10;
    vector<int> A(N);
    generate(A.begin(), A.end(), [i = 0]() mutable { return i++; });
    copy(A.begin(), A.end(), ostream_iterator<int>(cout, " "));
    cout << endl;
    return 0;
}

Answer 8

仅仅使用动态数组？

type * pointer;
pointer = new type[number_of_elements];

void main() 
{
int limit = 0; // Your lucky number
int * pointer = NULL; 
cout << "Please, enter limit number: ";           
cin >> n;
pointer = new int[limit+1]; // Just to be sure.
    for (int i = 0; i < n; i++) 
    {
         pointer[i] = i; // Another way is: *(pointer+i) = i (correct me if I'm wrong)   
    }
delete [] pointer; // Free some memory
pointer = NULL; // If you are "pedant"
}

我不会假装这是最好的解决方案。希望对你有帮助。

Answer 9

应该帮到你

int* a = NULL;   // Pointer to int, initialize to nothing.
int n;           // Size needed for array
cin >> n;        // Read in the size
a = new int[n];  // Allocate n ints and save ptr in a.
for (int i=0; i<n; i++) {
    a[i] = 0;    // Initialize all elements to zero.
}
. . .  // Use a as a normal array
delete [] a;  // When done, free memory pointed to by a.
a = NULL;     // Clear a to prevent using invalid memory reference