Question

赋值的下一部分告诉我，类RacingCar包含由Wheel类定义的四个轮对象。将轮子实现为堆上的对象数组。

class RacingCar{
    int speed;

public:
    void Accelerate(int value) {
        speed = speed + value;
    }

    void Brake(int value) {
        speed = speed - value;
    }

    void Turn(int value) {
        speed = value / 4;
    }

    void Print(){
        cout << "The current KM/h of the car is: " << speed;
    }
};

class Wheel {
    int *ptrSize;
    int pressure;

public:
    Wheel() : pressure(32) {
        ptrSize = new int(30);
    }

    Wheel (int s, int p) : pressure(p) {
        ptrSize = new int(s);
    }

    ~Wheel() {
        delete ptrSize;
    }

    void pump(int amount) {
        pressure += amount;
    }

    void print() {
        cout << pressure;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Wheel *heapArray = new Wheel[4];
    RacingCar F1; //Creating a "Formula 1" test car

    //Test parameters
    F1.Accelerate(10);
    F1.Brake(50);
    F1.Turn(180);
    F1.Print(); //Checks to see if the car changes actually worked

    getch();

    delete [] heapArray; //Delete when you're done
    return 0;
}

构建像这样的类，然后在RacingCar内访问它是否理想？或者有更好的方法吗？我无法看到在堆上创建它的方法。

Answer 1

将轮子实现为堆上的对象数组。

真的有点无趣，但这是一个练习，所以......

赋值告诉我，类“RacingCar”包含四个轮子对象，由Wheel类定义。

当你的作业说“包含四个轮对象”时，你可以将这个要求翻译成“轮对象应该是我班级的成员”。

我假设你的教练希望你在RacingCar类的ctor中初始化wheel-object-array，然后在RacingCar类的dtor中释放它（delete[]）。

但请注意，执行此操作的正确方法是：

class Wheel;

class RacingCar {
...
std::vector<Wheel> wheels; // if you need a variable amount of wheels
Wheel wheels[4]; // if you need exactly 4 wheels.
...

即使你真的必须在堆上分配Wheel对象，你仍然不会使用delete[]，但最好使用boost::scoped_array之类的工具。

让我们充实一点，因为我们想要SO的完整答案，即使对于“家庭作业”问题，对吗？

如上所述，建模包含通常是通过类的成员完成的，尽管在这种情况下，类的成员可能是某种类型的数组。

鉴于要求在堆上分配Wheel （虽然它对玩具示例没有意义，但是有很多合法的用例来分配类的对象成员方案中的堆） - 我会说以下解决方案是好风格：

这将为您提供一个恰好有4个堆分配对象的数组。您不需要明确释放这些内容：

class RacingCar {
...
boost::scoped_array<Wheel> wheels;
...
RacingCar()
: wheels(new Wheel[4])
{ }
...

这使用了4个单独的成员，这些成员在某些用例中可能有意义，在这些用例中，您拥有相同类的成员，但不要统一使用它们：

class RacingCar {
...
boost::scoped_ptr<Wheel> front_left;
boost::scoped_ptr<Wheel> front_right;
boost::scoped_ptr<Wheel> rear_left;
boost::scoped_ptr<Wheel> rear_right;
...
RacingCar()
: front_left(new Wheel)
, front_right(new Wheel)
, rear_left(new Wheel)
, rear_right(new Wheel)
{ }

如果您想使用可变尺寸，您可以：

class RacingCar {
...
boost::ptr_vector<Wheel> wheels;
...
RacingCar() {
  for(size_t i=0; i<4; ++i) {
    wheels.push_back(new Wheel);
  }
}
...

最后，如果你没有提升但是普通的C ++，我会这样做:(哦，请注意我在第一版中如何忘记添加副本ctor operator。这就是你不去搞乱原始指针和删除的原因。你永远都会忘记......; - ）

class RacingCar {
...
Wheel* wheels;
...
RacingCar()
: wheels(new Wheel[4])
{ }
~RacingCar() {
  delete[] wheels;       
}
private:
// Block copy operations. These would need to be
// implemented properly for the wheels member.
RacingCar(RacingCar const&); // no impl.
RacingCar& operator=(RacingCar const&); // no impl.
...

Answer 2

分配意味着Wheel的数组应该是类RacingCar的一部分，就像

一样

class RacingCar {
public:
    ...
private: 
    ...
    Wheel *wheels;

};

你应该在构造函数中分配它，然后在析构函数中销毁它。

Answer 3

我认为最好将“* heapArray”添加为RacingCar的属性并在其构造函数中创建轮子。

如何从另一个类中访问一个类？

3 个答案: