Question

我需要在C ++中填充int []数组，从0到变量定义的数字，但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());

你也可以使用vector作为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 ++代码段将值0..9（含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

它应该是你的帮助

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

Answer 9

只需使用动态数组？

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"
}

我不假装这是最好的解决方案。我希望它有所帮助。

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

9 个答案: