指针、对象指针和类的帮助

Question

我正在寻找正确的方向。 我有 1 个班级活动

class Event{
private:
 vector<string> Question;
 char Mode;// 1 = Ascending 2 = Descending 3 = None
 string EventName;
public:
    Event(string Name){
        EventName = Name;
        SetQuestionSize();
        SetQuestion();
        Mode = 3; 
    }

    void SetName(string NewName){
        EventName = NewName;
    }
    void SetQuestionSize(){
        Question.resize(15);
    }

    int ReturnQuestionSize(){
        return Question.size();
    }

    void SetQuestion(){
        Question[0]="Enter ";
        Question[1]="1 ";
        Question[2]="to ";
        Question[3]="sort ";
        Question[4]="in ";
        Question[5]="ascending ";
        Question[6]="order, ";
        Question[7]="2 ";
        Question[8]="for ";
        Question[9]="Descending, ";
        Question[10]="or ";
        Question[11]="3 ";
        Question[12]="to ";
        Question[13]="ignore ";
        Question[14]=EventName;
    }

    string ReturnQuestion(int Index){
        return Question[Index];
    }

    /*vector<string> ReturnQuestion(){
 return Question;
    }*/

    void SetMode(char NewMode){
 if (NewMode == '0' || NewMode == '1' || NewMode == '2')
 Mode = NewMode;
}

    char ReturnMode(){
 return Mode;
    }

    string ReturnName(){
        return EventName;
    }
};

这将是第二个对象的成员，它将使用 Event 的函数将数据存储在 Event 的成员中。

我遇到的问题是在我的第二个对象中声明一个 Event 对象数组。在研究时，我遇到了使用指向第一个对象的指针数组的方法，而我猜想的一些运算符“->”与虚函数有关。

class WhatTheyWant{
    Event *events[2];
public:
    WhatTheyWant(){
        events[0]= new Event("Miss");
        events[1]= new Event("Dodge");
    }
};

我对指针一无所知，我知道我最终将不得不学习它们，但它们是最好的方法还是有更好的方法。

Answer 1

由于您的Event 类没有默认构造函数，因此您需要使用其名称显式构造每个对象，因此您当前的操作方式是唯一的方法。

如果你给Event添加一个默认构造函数，你至少可以通过其他两种方式来实现：

如果你总是有一个（小）固定数量的对象，你可以声明一个恒定大小的数组：

Event events[2];

这样做会在创建WhatTheyWant时自动构造对象，所以你只需要在之后设置名称：

WhatTheyWant() {
  events[0].SetName("Miss");
  events[1].SetName("Dodge");
}

如果你想拥有可变数量的事件，你可以声明一个指针并动态分配一个对象数组：

Event *events;

您可能可以将数字作为参数提供给构造函数：

WhatTheyWant(int numEvents) {
  events = new Event[numEvents];
  for (int i = 0; i < numEvents; i++)
    events[i]->SetName("...");
}

---

此外，与您的问题没有直接关系，但您的 Mode 变量最好使用枚举而不是 char 进行建模。使用 enum 可以更清楚地了解变量的真正含义，而不是使用 0、1 和 2 之类的值。例如：

public:
  enum ModeType { Ascending, Descending, None };
private:
  ModeType Mode;
public:
  Event() {
    ...
    Mode = Ascending;
  }
  void SetMode(ModeType NewMode) {
    Mode = NewMode;
  }
  ModeType ReturnMode() {
    return Mode;
  }

Answer 2

您可以使用对象数组或指针数组。

对象数组如下所示。

class WhatTheyWant{ 
    Event events[2]; 
public: 
    WhatTheyWant()
    { 
       events[0] = Event("Miss");
       events[1] = Event("Dodge");
    } 
 }; 

注意：您需要在事件类中添加默认构造函数才能编译上述方法。

使用上述方法，您无需关心释放 Event 对象。每当 WhatTheyWant 对象被销毁时，事件对象就会被销毁。

指针数组方法就像你提到的那样。

但是您需要注意释放分配的内存（除非您使用 auto_ptr 或某些 c++0x 等效项）。 删除应该发生在如下的析构函数中。

class WhatTheyWant{ 
    Event *events[2]; 
public: 
    WhatTheyWant(){ 
        events[0]= new Event("Miss"); 
        events[1]= new Event("Dodge"); 
    } 
    ~WhatTheyWant()
    {
        delete events[0];
        delete events[1];
    }
};

Answer 3

在 C++ 中，指针就像数组一样

在您的 WhatTheyWant 类中，您定义私有成员：

Event *events[2];

这是一个数组数组（二维数组），长度可变（数组），每个数组有 2 个元素。

当你想访问一个（某种对象的成员）并且称为对象指针（指向一个对象的指针）但是当你定义一个普通的对象变量时使用运算符'->'你用 '。'运算符。

如果你有勇气和知识使用它们，它们会非常有用，但总的来说它们很危险，这就是为什么新语言倾向于采用托管方式的原因。