C++ 动态字符串数组分配错误

我试图按以下方式分配动态字符串数组，但出现错误：

struct Test
{
    std::string producer[];
    std::string golden[];
};

Test test1 =
{
        {"producer1", "producer2"} ,
        {"golden1"  , "golden2"}
};

我得到的错误是，

std:：string[0]

的初始值设定项太多， 但如果我离开阵列部分，它会工作：

struct Test
{
    std::string producer;
    std::string golden;
};

Test test1 =
{
        "producer1" ,
        "golden1"
};

---

提前谢谢

您不能以这种方式初始化零大小的数组，因为您必须动态地分配内存。只有在类型定义中指定尺寸标注时，才能执行该操作

---

请参阅我对类似问题的回答。

您不能以这种方式初始化零大小的数组，因为您必须动态地分配内存。只有在类型定义中指定尺寸标注时，才能执行该操作

---

请参阅我对类似问题的回答。

您可以使用C++11统一初始化：

struct Test
{
    vector<string> producer;
    vector<string> golden;  
};

Test test1 =
{
    {"producer1", "producer2"},
    {"golden1", "golden2"}
};

struct测试
{
媒介生产者；
矢量金；
};
测试1=
{
{“producer1”、“producer2”}，
{“golden1”、“golden2”}
};

下面的示例代码可以用g++很好地编译：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct Test
{
    vector<string> producer;
    vector<string> golden;  
};


ostream & operator<<(ostream & os, const Test & test)
{
    os << "------------------------" << endl;
    os << "producer={" << endl;
    for (auto& p : test.producer)
    {
        os << '\t' << p << endl;
    }
    os << "}" << endl;

    os << "golden={" << endl;
    for (auto& p : test.golden)
    {
        os << '\t' << p << endl;
    }
    os << "}";
    os << "------------------------" << endl;

    return os;   
}



int main()
{
    Test test1 =
    {
         {"producer1", "producer2"},
         {"golden1", "golden2"}
    };

    cout << test1 << endl;


    return 0;
}

#包括
#包括
#包括
使用名称空间std；
结构测试
{
媒介生产者；
矢量金；
};
ostream&operator您可以使用C++11统一初始化：

struct Test
{
    vector<string> producer;
    vector<string> golden;  
};

Test test1 =
{
    {"producer1", "producer2"},
    {"golden1", "golden2"}
};

struct测试
{
媒介生产者；
矢量金；
};
测试1=
{
{“producer1”、“producer2”}，
{“golden1”、“golden2”}
};

下面的示例代码可以用g++很好地编译：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct Test
{
    vector<string> producer;
    vector<string> golden;  
};


ostream & operator<<(ostream & os, const Test & test)
{
    os << "------------------------" << endl;
    os << "producer={" << endl;
    for (auto& p : test.producer)
    {
        os << '\t' << p << endl;
    }
    os << "}" << endl;

    os << "golden={" << endl;
    for (auto& p : test.golden)
    {
        os << '\t' << p << endl;
    }
    os << "}";
    os << "------------------------" << endl;

    return os;   
}



int main()
{
    Test test1 =
    {
         {"producer1", "producer2"},
         {"golden1", "golden2"}
    };

    cout << test1 << endl;


    return 0;
}

#包括
#包括
#包括
使用名称空间std；
结构测试
{
媒介生产者；
矢量金；
};
ostream&operator
std:：字符串生成器[]在声明数组时不能不说明数组应包含多少元素。@可以，但不能定义它，必须动态执行。@LittledV是的，但非静态成员声明是一种定义，需要大小。您不能动态分配任何已声明的内容。要动态分配
字符串[]
，必须将对象定义为
字符串*
，而不是
字符串[]
。只有在
字符串[]
实际合法的地方才是作为
extern
，或者作为函数的引用参数（但这有点棘手，因为你不能向函数传递一个大小已知的数组）。@James，我不会在注释中解释，但你错了。注意，他在这里定义了一个类型。他正在定义一个类，类中的非静态数据成员声明是定义，并且需要大小，请参见§9.2/10（“非静态数据成员不得具有不完整的类型”）
std:：string producer[]在声明数组时不能不说明数组应包含多少元素。@可以，但不能定义它，必须动态执行。@LittledV是的，但非静态成员声明是一种定义，需要大小。您不能动态分配任何已声明的内容。要动态分配
字符串[]
，必须将对象定义为
字符串*
，而不是
字符串[]
。只有在
字符串[]
实际合法的地方才是作为
extern
，或者作为函数的引用参数（但这有点棘手，因为你不能向函数传递一个大小已知的数组）。@James，我不会在注释中解释，但你错了。注意，他在这里定义了一个类型。他定义了一个类，类中的非静态数据成员声明是定义，需要大小，请参见§9.2/10（“非静态数据成员不应具有不完整的类型”）