聚合对象需要初始化为“ {…}”

Question

我正在尝试进行字符串解析（事实证明这是一个巨大的痛苦）。 我收到此错误：“预期对聚合对象进行'{...}'初始化”

我有一个这样定义的元素：

Element * currentBar = new Element("Bar");

我想制作一个数组或类似的东西来存储多个酒吧，所以我试图做这样的事情：

Element allBars [] = new Element("Bars");

我很确定这不是我想要做的，尤其是因为我收到此错误“预期聚合对象使用'{...}'初始化”

这是我的代码的一部分：

if(!chartDataString.empty()){ 
    chartData.clear();
    int index = 0;
    char c, c1, c2;
    inputMode currentInputMode = inputMode::UNKNOWN;
    Element * cur = NULL;
    while(index<chartDataString.size()){
        c = chartDataString[index];
        c1 = chartDataString[index+1];
        c2 = chartDataString[index+2];
        string s;
        s = c1;
        Element * currentBar = new Element("Bar");
        Element allBars [] = new Element("Bars");                               
            if(c == '*'){
            if(c1 == 'i'){
                currentBar->addChild(Element("rehearsalLetter", "info"));
            }
            else{
                currentBar->addChild(Element("leftDoubleBarLine", s));
                index++;
            }
        else if(c == '['){
            currentBar->addChild(Element("leftDoubleBarLine"));
        }
        else if(c == 'T'){
            string signature = string() + c1 + '/' + c2;
            currentBar->addChild(Element("timeSignature", signature));
            index += 2;
        }
        //start a new bar
        else if(c == '|'){
            allBars->addChild(currentBar);
            currentBar = new Element("bar");
        }

还有我的元素类，以防万一：

#include <string>
#include <ostream>
#include "ArrayList.h"


class Element{
public:
    Element(){}
    Element( const string& _title ){
        title = _title;
    }
    Element( const string& _title, const string& _value){
        title = _title;
        value = _value;
    };
    ~Element(){};

    void addChild(Element & child){
        children.add(child);
    }

    void serialize(ostream & o ){
        if( children.size() == 0 ){
            o << "<" << title << ">";
            o << " " << value << " ";
            o << "</" << title << ">";
        }else{
            o << "<" << title << ">" << endl;
            for( int i = 0; i < children.size(); ++i ){
                children.elementAt(i).serialize(o);
            }
            o << "</" << title << ">" << endl;
        }
    }
private:
    string title;
    string value;
    ArrayList<Element> children;

};

Answer 1

当您声明变量Element allBars [] ，编译器确实期望像{ Element("Bar"), Element("Foo") }这样的值列表。 这是一个静态数组，其大小在编译时已知。 因此，例如：

Element allBars [] = { Element("Bar"), Element("Foo") };

（请注意，某些编译器确实需要在[]指定元素的数量）。

如果要声明动态数组，则可以使用std::vector<Element> allBars; ，我强烈建议您这样做，因为它会导致增长和收缩，而您不必担心内存分配和释放。 您的类应具有默认构造函数，复制构造函数和赋值运算符（即使由编译器生成）。

或者，您可以使用一个用new Element[xxx]填充的指针，例如Element* allBars = new Element[size_of_array]; ，它既不能增长也不能缩小，并且必须使用delete[]显式删除才能为数组的每个元素调用Element析构函数。

在这两种情况下，都将使用默认构造函数初始化数组的每个Element 。

Answer 2

您是否要使用单个Element初始化数组，但希望其大小有所变化？ 如果是这样，请使用向量：

vector<Element*> allBars;
vector.push_back(new Element());

如果您能够使用C ++ 11，请考虑使用unique_ptr以确保没有内存泄漏，并在添加到向量中时使用emplace_back避免复制：

vector<unique_ptr<Element>> allBars;
vector.emplace_back(unique_ptr<Element>(new Element()));