Question

我当前的项目要求我根据其他一些值填充数组。我知道有捷径：

int arr[4][4] = { {0,0,0,0} , {0,0,0,0} , {0,0,0,0} , {0,0,0,0} };

但在这种情况下，我需要在声明后填充数组。我目前的代码格式如下：

int arr[4][4];
if(someothervariable == 1){
    arr = { {1,1,1,1},
            {1,2,3,4},
            {2,,3,4,5},
            {3,4,5,6} };
}

但它不会编译。有没有办法在我的案例中使用上面提到的快捷方式？如果没有，最好的解决办法是什么？我很欣赏一种设置它的方法，而不是明确地分配每个元素？即：arr [0] [0] = ...

Answer 1

如何使用std :: copy（）？

int arr[4][4];
if(someothervariable == 1){
        const static int a2[4][4] = { {1,1,1,1},
                                      {1,2,3,4},
                                      {2,3,4,5},
                                      {3,4,5,6} };
        std::copy(&a2[0][0], &a2[0][0]+16, &arr[0][0]);
}

Answer 2

不，数组初始化语法用于数组初始化。但是，如果所有值都是相同的字节，则可以使用memset。

boost.assign库为修改/填充集合添加了一些有趣的语法，但AFAIK它不支持C样式数组（只有C ++和Boost容器）。

Answer 3

在当前版本的C ++语言中，唯一的方法是从原始的

复制它

int arr[4][4];

if (someothervariable == 1)
{
  const int SOURCE[4][4] = // make it `static` if you prefer
  { 
    {1, 1, 1, 1},
    {1, 2, 3, 4},
    {2, 3, 4, 5},
    {3, 4, 5, 6} 
  };

  assert(sizeof arr == sizeof SOURCE); // static assert is more appropriate
  memcpy(&arr, &SOURCE, sizeof arr);
}

源“常量”可以声明为static，以避免重新初始化，如果编译器不够智能，无法自行优化它。

在该语言的未来版本中，计划了一个类似于C的复合文字的功能，它将为即时初始化提供支持（基本上是你在原始帖子中尝试做的）。

Answer 4

如果您希望使用单个值填充数组：

#include<algorithm>
#include<vector>

// ...
std::vector<int> arr;
std::fill(arr.begin(), arr.end(), VALUE);  // VALUE is an integer

如果您想计算每个元素的值：

struct get_value {
    int operator()() const { /* calculate and return value ... */ }
};

std::generate(arr.begin(), arr.end(), get_value());

Answer 5

如果您将所有内容设置为相同的值（例如零），您可能可以逃脱......

memset (arr, 0, sizeof (arr));

请注意，这充满了危险。您必须知道您的类型大小和所有爵士乐。

但是，这似乎不适合你。如果你想用不同的值填充数组，我只能想到两种方法。

方法＃1。（可能是痛苦的屁股）

arr[0][0] = 1;
...
arr[0][3] = 1;
arr[1][0] = 1;
...
arr[1][3] = 4;
arr[2][0] = 2;
...
arr[2][3] = 5;
arr[3][0] = 3;
...
arr[3][3] = 6;

方法＃2。预定义一组数组并使用指针在它们之间切换;

int  arr1[4][4] = {
        {0,0,0,0},
        {0,0,0,0},
        {0,0,0,0},
        {0,0,0,0} };
int  arr2[4][4] = {
        {1,1,1,1},
        {1,2,3,4},
        {2,,3,4,5},
        {3,4,5,6} };

int *arr[4];

现在你只需设置* arr []的四（4）个值而不是设置所有内容。当然，这只有在你的数组充满预定常量时才有效。

希望这有帮助。

Answer 6

我不确定我是否喜欢这个解决方案，但是如果你将数组包装在一个结构中，只需要使用结构名称来获取数组，那么C / C ++将为你提供分配的便利性：

typedef struct {
    int data[4][4];
} info_t;

info_t arr;

if (someothervariable == 1){
    static const info_t newdata = {{  // since this is static const, there generally
                                      // won't be a copy - that data will be 'baked' 
                                      // into the binary image (or at worst a
                                      // single copy will occur)
        {1,1,1,1},
        {1,2,3,4},
        {2,3,4,5},
        {3,4,5,6} 
    }};
    arr = newdata;  // easy to assign new data to the array
}

int somethingelse = arr.data[1][2]; // a tiny bit less convenient to get 
                                    //    to the array data

Answer 7

int arr[4][4];
if (someothervariable == 1) {
     int tmp[4][4] = { {1, 1, 1, 1}, {1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6} };
     arr = tmp;
}

设置整个数组的最简单方法是什么？

7 个答案: