Question

C ++如何在类中使用数组

创建子类

大家好，我还在学习C ++，并在这里遇到一些问题。

基本上我有一个父类

允许将此父类称为

Vehicle

它有2个子类，让我们假设它们是

Car and Motorcycle

假设车辆尺寸为20

，我将创建一个车辆对象

Vehicle veh[20]

我会做以下

string vType;

cout << "Please enter your vehicle Type:";
cin >> vType;

所以我做了一个比较if（vType ==“Car”）

它会从子类返回4个轮子，但是如何在摩托车上宣布其4个车轮和2个轮子，我知道我需要创建2个额外的cpp文件

class Car : public Vehicle
{
private:
int noOfWheels;
public:
computePrice();
}

但是如何将noOfWheels专门设置为Car为4，摩托车为2。

接下来是棘手的部分..知道了多少轮后

我需要为每个轮子存储一个数组

string wheel[4];

因为我知道有4个车轮。

如何提示4类型并将其存储在数组中，并且所有这些都在对象中调用Vehicle。

我可以使用for循环，这不是问题，我坚持的部分是如何创建一个字符串数组并存储4提示然后进入此Vehicle [0]

wheel 1:
wheel 2:
wheel 3:
wheel 4:

当用户想要打印数据时，它将是

Vehicle[0]
Type: Car
Wheel: 4
Wheel[0] = Fine condition
Wheel[1] = Need to check again
Wheel[2] = Fine condition
Wheel[3] = Might need get repair

感谢您的帮助。

Answer 1

首先，你的数组的声明是错误的。由于您正在处理多态类，因此需要使用指针。

Vehicle* veh[20];

否则您将拥有所谓的对象切片。这意味着即使您创建了Car或Motorcycle，当您将它们分配给数组时，它们也会转换为Vehicle。

'如何将noOfWheels专门设置为Car为4，摩托车为2。'

在构造函数

中

class Car : public Vehicle
{
public:
    Car() : noOfWheels(4) { ... }
private:
    int noOfWheels;
    ...
};

class Motorcycle : public Vehicle
{
public:
    Motorcycle() : noOfWheels(2) { ... }
private:
    int noOfWheels;
    ...
};

但我个人认为你根本不需要noOfWheels数据成员。由于每种类型车辆的车轮数量是固定的，这是浪费空间，而不是你需要一个虚拟功能

class  Vehicle
{
public:
    virtual int noOfWheels() const = 0;
    ...
};

class Car : public Vehicle
{
public:
    virtual int noOfWheels() const { return 4; }
    ...
};

class Motorcycle  : public Vehicle
{
public:
    virtual int noOfWheels() const { return 2; }
    ...
};

'我如何创建一个字符串数组并将4提示存储到此Vehicle [0]'

中

我再次使用构造函数初始化车轮名称。

class Car : public Vehicle
{
public:
    Car(const std::string* w)
    { wheel[0] = w[0]; wheel[1] = w[1]; wheel[2] = w[2]; wheel[3] = w[3]; }
    virtual int noOfWheels() const { return 4; }
private:
    std::string wheel[4];
    ...
};

使用构造函数初始化类。这就是它们的用途。

Answer 2

看起来答案已被接受，但我输入了所有内容，所以我会将其全部发布。我想这是一个OOP的耗尽。

让我们假设所有车辆都有车轮。所有这些车轮都有条件。有些车辆的轮子比其他车辆多或少。

您需要将类的常用方面分为更高级别的基类。

您还需要组织您的类以与其他类组合以构建整体。

这里我们有一个轮子类，它有一个condition，它是一个字符串。您可以随时查询它的状况。

class Wheel 
{
  public:
    const std::string GetCondition() const { return mCondition; }
  private:
    std::string mCondition;
};

我们知道车辆会有轮子，所以我们将轮子容器存放在这里，通过继承在子类中分享。

class Vehicle
{
  public:
    Vehicle(unsigned int wheelCount) { mWheels.resize(wheelCount, Wheel()); }
    virtual unsigned int GetWheelCount() { return mWheels.size(); }
    virtual const std::string GetWheelCondition(int wheelNumber)
    {
      return mWheels[wheelNumber].GetCondition();
    }
  protected:
    std::vector<Wheel> mWheels; // All vehicles have wheels.
};

汽车是Vehicle的类型。因此，从Vehicle继承。它继承了一个包含Wheel个对象的成员。它还继承了有助于查找轮数和通过索引获取轮子状态的方法。这是您可以专门研究类的级别。 Car和Motorbike类都有轮子，它们具有相同的核心功能。我们可以通过添加或重载方法来专门化类。

class Car : public Vehicle
{
  public:
    Car() Vehicle(4) {}
    Car(unsigned int wheelCount) : Vehicle(wheelCount) {}
}

class Motorbike : public Vehicle
{
  public:
    MotorBike(unsigned int wheelCount) : Vehicle(wheelCount) {}
    void DoWheelie() { throw; }
}

我们可以像这样使用这些对象，

Car car(4); // Car with 4 wheels. specialized constructor.
Car standardCar(); // Car with 4 wheels, as default constructor.
Car uberCar(42); // Car with 42 wheels.    
Motorbike bike(2); // Bike with 2 wheels.
Motorbike badBike(); // No default constructor defined! Will not compile!

car.GetWheelCount(); // 4
bike.GetWheelCount(); // 2

bike.DoWheelie(); // All good.
car.DoWheelie(); // NOPE! Method doesn't exist for this.

关于多态性和堆分配的好处还有更多的说法，但我想我会把它留在这里。希望它有用。

C ++如何在类中使用数组创建子类

2 个答案: