1

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

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] = ...

4

7 回答 7

2

使用 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]);
}
于 2010-06-09T22:31:38.023 回答
1

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

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

于 2010-06-09T22:26:11.233 回答
1

在当前版本的 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 的复合文字的功能，它将为立即初始化提供支持（基本上是您在原始帖子中尝试做的）。

于 2010-06-09T22:29:26.540 回答
1

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

#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());
于 2010-06-09T22:30:45.017 回答
0

我不确定我是否喜欢这个解决方案，但是如果你将数组包装在一个结构中，那么 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
于 2010-06-09T22:54:58.763 回答
0

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

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) 个值，而不是设置所有内容。当然，这仅在您的数组将填充预定常量时才有效。

希望这可以帮助。

于 2010-06-09T22:34:13.993 回答
-2 
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;
}
于 2010-06-09T22:28:21.073 回答