C++；使用带有引用的对象向量的语法 我已经使用C相当长时间了，但是我想用C++面向对象的样式来处理当前项目，因为它的复杂性似乎更适合于这种方法。所以，我是一个新手，最好的实践是C++，我希望有人能帮我弄清楚如何做到这一点，希望直接的事情。

我花了一周的时间阅读这个网站和教程，学习引用，将它们传递给函数，在另一个类中初始化静态类成员，以及其他一些我很高兴知道的东西，但是我认为我已经在初级阶段了解了每种引用的基本思想，我很难理解如何把它们组合起来

这是我为测试我的概念理解而编写的思维实验程序

在这里，我定义了一个“Button”类，其中包含一些当前微不足道的成员

然后我定义了一个“Wand”类，它在概念上是一种将按钮组织成一组按钮的方法

编辑：根据Steven的有用回复，我更新了代码，尝试他的建议布局。这对我来说很有意义。我修正了一些我认为可能是打字错误的小事情，但我认为这其中有一些微妙的地方，那就是我做错了。我为std:：String添加了“String”子项，因为它是Arduino

#include <vector>

class Button {
  private:
    bool _active;
    String _title;
    float _value;
  public:
    Button(String title, float value) : _title(title) , _value(value) {}
    void setButton(bool active) {
      _active = active;
    };
    String getTitle(void) {
      return _title;
    };
    float getValue(void) {
      return _value;
    };
    void setValue(float newvalue) {
       _value = newvalue;
    };
};

class Wand {
  private:
    std::vector<Button> _Buttons;
    int _numButtons;
  public:
    Wand() {};
    Button& addButton(String title, float value) {
      _Buttons.push_back(Button(title, value));
      return _Buttons.back();
    }
    Button& getButton(int number) {
      return _Buttons[number];
    };
    int numButtons(void) {
      return _Buttons.size();
    };
};

void setup() {
  // put your setup code here, to run once:
  SerialUSB.begin(9600);

  Wand wand = Wand();
  Button& OkButton = wand.addButton("Okay Button", 0);
  Button& NokayButton = wand.addButton("Nokay Button", 0);
  while(1) {
    SerialUSB.println(wand.getButton(0).getTitle() + "(via Wand): "+ wand.getButton(0).getValue());
    SerialUSB.println(OkButton.getTitle() + "(via Button): "+ OkButton.getValue());
    SerialUSB.println(wand.getButton(1).getTitle() + "(via Wand): "+ wand.getButton(1).getValue());
    SerialUSB.println(NokayButton.getTitle() + "(via Button): "+ NokayButton.getValue());

    OkButton.setValue(OkButton.getValue()+1);
    NokayButton.setValue(NokayButton.getValue()-1);
    delay(500);
  }

}

void loop() {
  // put your main code here, to run repeatedly:

}

显然，我正在正确地更新和访问第二个按钮，但第一个按钮似乎再次创建了该类的两个实例，一个在wand中，没有更新，另一个引用版本正在更新

原职：

现在，我已经阅读了关于std:：vector的内容，它似乎是一种自然的方式，可以在一根魔杖中存储动态分配的按钮数组。但当我使用Wand的成员函数读取值时，很明显我没有使用最初分配的按钮对象

在这段代码中，我看到了实际按钮更改的值，但是通过按钮向量请求时的值是不同的。我试着加了一些符号，但它主要只是导致编译器错误

有人能告诉我如何正确地做这种事吗？或者，如果这是一种完全错误的方法，那么可以链接到如何以更标准的方式进行学习

#include <vector>

class Button {
  private:
    bool _active;
    char* _title;
    float _value;
  public:
    Button(char* title, float value) : _title(title) , _value(value) {}
    void setButton(bool active) {
      _active = active;
    };
    char* getTitle(void) {
      return _title;
    };
    float getValue(void) {
      return _value;
    };
    void setValue(float newvalue) {
       _value = newvalue;
    };
};

class Wand {
  private:
    std::vector<Button> _Buttons;
    int _numButtons;
  public:
    Wand() {};
    void addButton(Button &newbutton) {
      _Buttons[_numButtons] = newbutton;
      _numButtons++;
    };
    Button& getButton(int number) {
      return _Buttons[number];
    };
    int numButtons(void) {
      return _numButtons;
    };
};


void setup() {
  // put your setup code here, to run once:
  SerialUSB.begin(9600);

  Wand wand = Wand();
  Button OkButton = Button("Okay Button", 0);
  Button NokayButton = Button("Nokay Button", 0);
  wand.addButton(OkButton);
  wand.addButton(NokayButton);
  while(1) {
    SerialUSB.println(wand.getButton(0).getValue());
    SerialUSB.println(OkButton.getValue());
    OkButton.setValue(OkButton.getValue()+1);
    SerialUSB.println(wand.getButton(1).getValue());
    SerialUSB.println(NokayButton.getValue());
    NokayButton.setValue(NokayButton.getValue()-1);
    delay(500);
  }

}

void loop() {
  // put your main code here, to run repeatedly:

}

#包括
类按钮{
私人：
布尔活跃；
char*\u标题；
浮点数；
公众：
按钮（字符*标题，浮点值）：_标题（标题），_值（值）{}
无效收进按钮（布尔激活）{
_主动=主动；
};
char*getTitle（void）{
返回标题；
};
浮点值（void）{
返回_值；
};
无效设置值（浮动新值）{
_值=新值；
};
};
类魔杖{
私人：
std：：矢量按钮；
内纽扣；
公众：
魔杖（）{}；
无效添加按钮（按钮和新按钮）{
_按钮[_numButtons]=新按钮；
_numButtons++；
};
按钮和获取按钮（整数）{
返回按钮[编号]；
};
int numButtons（无效）{
返回按钮；
};
};
无效设置（）{
//将安装代码放在此处，以便运行一次：
SerialUSB.begin（9600）；
魔杖魔杖=魔杖（）；
按钮OK按钮=按钮（“OK按钮”，0）；
按钮NokayButton=按钮（“Nokay按钮”，0）；
棒。添加按钮（OK按钮）；
魔杖。添加按钮（NokayButton）；
而(1){
SerialUSB.println（wand.getButton（0.getValue（））；
SerialUSB.println（OkButton.getValue（））；
OkButton.setValue（OkButton.getValue（）+1）；
SerialUSB.println（wand.getButton（1.getValue（））；
SerialUSB.println（NokayButton.getValue（））；
NokayButton.setValue（NokayButton.getValue（）-1）；
延迟（500）；
}
}
void循环（）{
//将主代码放在此处，以便重复运行：
}

将按钮添加到魔杖时，就是将副本添加到向量中，因此向量中按钮的地址与OK按钮和NoOkButton的地址不同

正如其他人指出的，使用std:：vector可能是最健壮的解决方案。但是，如果确实要使用向量，可以在向量完成后创建按钮的可编辑引用。但这有点危险，因为std:：vector保证了连续内存，因此，如果没有空间容纳新元素，则在添加新元素时，单个元素的地址可能会更改。以下是代码（未测试）：

#包括
类按钮{
私人：
布尔活跃；
std:：string _title；
浮点数；
公众：
按钮（标准：：字符串标题，浮点值）：\u标题（标题），\u值（值）{}
无效收进按钮（布尔激活）{
_主动=主动；
};
std:：string getTitle（void）{
返回标题；
};
浮点值（void）{
返回_值；
};
无效设置值（浮动新值）{
_值=新值；
};
};
类魔杖{
私人：
std：：矢量<按钮>\u按钮；
公众：
魔杖（）{}；
void addButton（标准：：字符串标题，浮点值）{
_按钮。向后推（按钮（标题、值））；
};
按钮和获取按钮（整数）{
返回按钮[编号]；
};
int numButtons（无效）{
返回按钮。大小（）；
};
};
无效设置（）{
//将安装代码放在此处，以便运行一次：
SerialUSB.begin（9600）；
魔杖魔杖=魔杖（）；
添加按钮（“确定按钮”，0）；
添加按钮（“Nokay按钮”，0）；
//如果在此之后添加按钮，则这些引用
//可能无效。
按钮&OkButton=wand.getButton（0）；
按钮&NokayButton=wand.getButton（1）；
而(1){
SerialUSB.println（wand.getButton（0.getValue（））；
SerialUSB.println（OkButton.getValue（））；
OkButton.setValue（OkButton.getValue（）+1）；
SerialUSB.println（wand.getButton（1.getValue（））；
SerialUSB.println（NokayButton.getValue（））；
NokayButton.setValue（NokayButton.getValue（）-1）；
延迟（500）；
}
}
void循环（）{
//将主代码放在此处，以便重复运行：
}

我还冒昧地演示了stl的一些其他特性。std：：str

#include <vector>

class Button {
  private:
    bool _active;
    char* _title;
    float _value;
  public:
    Button(char* title, float value) : _title(title) , _value(value) {}
    void setButton(bool active) {
      _active = active;
    };
    char* getTitle(void) {
      return _title;
    };
    float getValue(void) {
      return _value;
    };
    void setValue(float newvalue) {
       _value = newvalue;
    };
};

class Wand {
  private:
    std::vector<Button> _Buttons;
    int _numButtons;
  public:
    Wand() {};
    void addButton(Button &newbutton) {
      _Buttons[_numButtons] = newbutton;
      _numButtons++;
    };
    Button& getButton(int number) {
      return _Buttons[number];
    };
    int numButtons(void) {
      return _numButtons;
    };
};


void setup() {
  // put your setup code here, to run once:
  SerialUSB.begin(9600);

  Wand wand = Wand();
  Button OkButton = Button("Okay Button", 0);
  Button NokayButton = Button("Nokay Button", 0);
  wand.addButton(OkButton);
  wand.addButton(NokayButton);
  while(1) {
    SerialUSB.println(wand.getButton(0).getValue());
    SerialUSB.println(OkButton.getValue());
    OkButton.setValue(OkButton.getValue()+1);
    SerialUSB.println(wand.getButton(1).getValue());
    SerialUSB.println(NokayButton.getValue());
    NokayButton.setValue(NokayButton.getValue()-1);
    delay(500);
  }

}

void loop() {
  // put your main code here, to run repeatedly:

}

#include <vector>

class Button {
  private:
    bool _active;
    std::string _title;
    float _value;
  public:
    Button(std::string title, float value) : _title(title) , _value(value) {}
    void setButton(bool active) {
      _active = active;
    };
    std::string getTitle(void) {
      return _title;
    };
    float getValue(void) {
      return _value;
    };
    void setValue(float newvalue) {
       _value = newvalue;
    };
};

class Wand {
  private:
    std::vector< Button > _Buttons;
  public:
    Wand() {};
    void addButton( std::string title, float value ) {
      _Buttons.push_back( Button( title, value ) );
    };
    Button& getButton(int number) {
      return _Buttons[number];
    };
    int numButtons(void) {
      return _Buttons.size();
    };
};


void setup() {
  // put your setup code here, to run once:
  SerialUSB.begin(9600);

  Wand wand = Wand();
  wand.addButton("Okay Button", 0);
  wand.addButton("Nokay Button", 0);

  // If you add buttons after this, these references 
  // may be invalid.
  Button& OkButton = wand.getButton(0);
  Button& NokayButton = wand.getButton(1);

  while(1) {
    SerialUSB.println(wand.getButton(0).getValue());
    SerialUSB.println(OkButton.getValue());
    OkButton.setValue(OkButton.getValue()+1);
    SerialUSB.println(wand.getButton(1).getValue());
    SerialUSB.println(NokayButton.getValue());
    NokayButton.setValue(NokayButton.getValue()-1);
    delay(500);
  }

}

void loop() {
  // put your main code here, to run repeatedly:

}