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对象数组。在研究时，我遇到了使用指向第一个对象的指针数组的方法，以及一些运算符' - ＆gt;'我猜的是与虚函数有关。

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];

这是一个数组（2D数组）数组，其长度（数组）和每个数组中有2个元素。

和运营商' - ＆gt;'当你想要访问（某种对象的成员）并且被称为对象指针（指向对象的指针）时使用，但是当你定义普通对象变量时，你使用'。'操作

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

帮助指针，指向对象和类

3 个答案: