Question

我正在学习C ++，我遇到了struct和数组的问题。我的结构是：

struct board
{
    string name;
    string desc;
    int nval;
    int sval;
    int eval;
    int wval;
};

我的数组看起来像这样：

board field[10][10];

我能够做到例如：

field[5][6].name = "ExampleName";
field[5][6].desc = "This is an example";
field[5][6].nval = 3;
//and so on...

但我想立刻分配给整个结构，如下所示：

field[5][6] = {"ExampleName", "This is an example", 3, 4, 5, 6};
//so I don't have to type everything over and over again...

Answer 1

C标准允许您尝试做的事情。它似乎也在C ++中工作。我在C ++ 11中验证了它：

struct board
{
string name;
string desc;
int nval;
int sval;
int eval;
int wval;
}field[10][10];

int main()
{    
field[5][6]={"ExampleName","This is an example",3,4,5,6};
cout<<field[5][6].name<<endl;
cout<<field[5][6].sval<<endl;
return 0;
}

正确打印。所以你应该能够做到这一点。

Answer 2

我担心你不能这样做。

但在现实生活中，这不是问题，因为您通常不需要手动填写此类字段。你通常会循环。

如果您不介意运行时初始化，我会这样做：

    // in the beginning make these arrays
string names[10*10] = {
    "example 1 name"
    "example 2 name"
    "blah blah blah "
};

string descriptions[100] = {

};
//and then just loop through that

int i,j;
for (int k = 0; k != 10*10; ++k) { // 10*10 size of a board
        if (j == 10) {
            j = 0;
            i++
        }

        field[i][j].name = names[k]// get it from names
        field[i][j].desc = // get somehow the description,...
        ++j
    }

}

Answer 3

如前所述，C99和C＃都支持该语法的一种形式，但标准C ++却不支持。您可以通过向结构中添加构造函数来进行。请注意，这将不再是ANSI C兼容。

struct board
{
    string name;
    string desc;
    int nval;
    int sval;
    int eval;
    int wval;

    board()
    {
    }

    board(string name, string desc, int nval, int sval, int eval, int wval)
    {
        this->name = name;
        this->desc = desc;
        this->nval = nval;
        this->sval = sval;
        this->eval = eval;
        this->wval = wval;
    }
};

field[1][2] = board("name", "desc", 1, 2, 3, 4);

Answer 4

如果定义带参数的构造函数，则可以使用它创建临时和初始化给定元素。您还需要定义和默认构造函数：

struct board
{
   string name;
   string desc;
   int nval;
   int sval;
   int eval;
   int wval;

   board():
     name(""),
     desc(""),
     nval(0),
     sval(0),
     eval(0),
     wval(0){}

   board(
     const string& name,
     const string& desc,
     int nval,
     int sval,
     int eval,
     int wval):
   name(name),
   desc(desc),
   nval(nval),
   sval(sval),
   eval(eval),
   wval(wval){}
};

int main()
{
   board field[10][10];
   field[5][6]= board("ExampleName","This is an example",3,4,5,6);
   return 0;
}

Answer 5

如果您确实需要为所有100个字段定义精选值，可以通过在文本文件中编写所有参数然后解析文件并使用提取的值填充数组来简化操作。该文件可能看起来像

0 0
Corner field
Here it begins
0 1 2 3

0 1
ExampleName
This is an example
3 4 5 6

等等。然后，在阅读文件时，您可以使用istream::getline提取文本字符串，使用istream::operator>>提取数字。

但它仍然很痛苦。您确定没有自动生成至少大部分值的方法吗？

Answer 6

关于一行的含义，问题不太明确，所以我将开始提供建议：

使用聚合初始化：

board fields[10][10] = { 
                  { {"ExampleName","This is an example",3,4,5,6}, // Element 0,0
                    {"ExampleName","This is an example",3,4,5,6}, // Element 0,1
                // ...
                  },
                  { {"ExampleName","This is an example",3,4,5,6}, // Element 1,0
                // ... 
                  }
                };

这是你可以获得的最接近单行的，它是有效的C ++（在所有变体中，假设board是聚合，因此board[10][10]也是聚合），但是它可能很难阅读。

下一步是接近你正在做的事情，即初始化每个元素（而不是数组），因为在C ++ 11中你可以使用与你建议的相同类型的初始化。在C ++ 03中，您需要通过构造函数执行此操作（注意，这将更改该类型的属性，您将需要为该数组创建默认构造函数）：

 struct board {
    string name;
    string desc;
    int nval;
    int sval;
    int eval;
    int wval;
    board() {}  // [*]
    board( const char* name, const char* desc, int n, int s, int e, int w )
       : name(name), desc(desc), nval(n), sval(s), eval(e), wval(w)
    {}
 };
 board fields[10][10];  // [*] this requires the default constructor [*]

 fields[5][6] = board("ExampleName","This is an example",3,4,5,6);

或通过功能：

board create_board( const char* name, const char* desc, ... ) {
   board res = { name, desc, ... };
   return res;
}

请注意，在这两种情况下，数组中的元素在数组初始化期间初始化，然后在它们之上复制一个新对象。

在数组中一次分配整个结构

6 个答案: