C++ C++；公共成员的替代方案

以这个例子为例

class Sprite    
{
public:
    Sprite(int imageID, int maskID);
    ~Sprite();
    //some methods
}

Sprite::Sprite(int imageID,int maskID)
{
    //this is the class for creating sprites in winapi..its doesnt matter what it has in this example
}

Sprite::~Sprite()
{
    DeleteObject ( mhImage );
    DeleteObject ( mhMask );
}

class Car{
public:
    enum Type{
        Ferrari,
        BWM
    };
    Car(Type type);
    ~Car();
    void InitSpeed()
    void ChangeSpeed();
    //..some methods
private:
    Sprite *car;
}

及其实施

Car::Car(Type type)
{
    switch(type)
    {
    case Ferrari:
        car=new Sprite("Ferrari","FerrariMask");
        break;
    case BMW:
        car=new Sprite("BMW","BMWMask");
        break;
    }
}

void Car::InitSpeed()
{
    speed=100;
}

void Car::ChangeSpeed()
{
    speed=200;
}

Car::~Car()
{
    delete car;
}

class BuildCar:public Car
{
public:
    BuildCar();
    ~BuildCar();
    Car*BMW;
    Car*Ferrari;
}

BuildCar::BuildCar()
{
    Ferrari=new Car(Ferrari);
    BMW=new Car(BMV)
}

BuildCar::BuildCar()
{
    delete Ferrari
    delete BMW;
}

在五月份的主要课程中，我将有：

#include "Car"

class Game
{
private:
    //etc
    BuildCar*mycars;

    //etc;
}

Game::Game()
{
    mycars=new BuildCar();
    mycars->BMW->InitSpeed();
    mycars=>Ferrari->InitSpeed();

    ....
    at some point i will have:
    mycars->BMW->ChangeSpeed();
    mycars->Ferrari->ChangeSpeed();
}

如果我是

Car*BMW

和

Car*Ferrari

的私人会员，整个程序将无法运行，因为我无法访问

BuildCar

类的私人会员

我可以让他们成为私家车，在

中建造汽车。我会添加一些setter和getter，这样我就可以访问它们，但若我有很多指向car的指针呢？我必须在
BuildCar
中制作许多setter和getter，例如：

Car*GetBMW()
{
    return BMW
}

Car*GetFerrari()
{
    return Ferrari;
}

Car* bmw = mycars->getBMW();
Car* ferrari = mycars->getFerrari();

bmw->ChangeSpeed();
// etc.

现在在我的主课上，它会起作用

mycars->GetBMW()->ChangeSpeed();
mycars->GetFerrari()->ChangeSpeed();

我知道公开班级成员是一种不好的做法，但在我的例子中又是怎样的呢？那么可以做些什么呢？
好吧，如果你预先定义了一种情况，在这种情况下，
mycars
对象只包含法拉利和宝马汽车-你的代码是绝对正确的。例如，您可以：

Car*GetBMW()
{
    return BMW
}

Car*GetFerrari()
{
    return Ferrari;
}

Car* bmw = mycars->getBMW();
Car* ferrari = mycars->getFerrari();

bmw->ChangeSpeed();
// etc.

但是你有十辆车。在这种情况下，
std:：vector
可能是一个更好的选择，尽管您可以通过汽车的数字ID来引用汽车

底线是在适当的C++中有很多方法来编写你想要的东西（这是一个幻象：）。您可以使用或不使用指针、智能指针或引用、映射、向量、数组等进行编写。只要你学习C++，就要按照你所知道的最好的方法去做。p> 好吧，如果你预先定义了一种情况，在这种情况下，
mycars
对象只包含法拉利和宝马汽车-你的代码是绝对正确的。例如，您可以：

Car*GetBMW()
{
    return BMW
}

Car*GetFerrari()
{
    return Ferrari;
}

Car* bmw = mycars->getBMW();
Car* ferrari = mycars->getFerrari();

bmw->ChangeSpeed();
// etc.

但是你有十辆车。在这种情况下，
std:：vector
可能是一个更好的选择，尽管您可以通过汽车的数字ID来引用汽车

底线是在适当的C++中有很多方法来编写你想要的东西（这是一个幻象：）。您可以使用或不使用指针、智能指针或引用、映射、向量、数组等进行编写。只要你学习C++，就要按照你所知道的最好的方法去做。p> 好吧，如果你预先定义了一种情况，在这种情况下，
mycars
对象只包含法拉利和宝马汽车-你的代码是绝对正确的。例如，您可以：

Car*GetBMW()
{
    return BMW
}

Car*GetFerrari()
{
    return Ferrari;
}

Car* bmw = mycars->getBMW();
Car* ferrari = mycars->getFerrari();

bmw->ChangeSpeed();
// etc.

但是你有十辆车。在这种情况下，
std:：vector
可能是一个更好的选择，尽管您可以通过汽车的数字ID来引用汽车

底线是在适当的C++中有很多方法来编写你想要的东西（这是一个幻象：）。您可以使用或不使用指针、智能指针或引用、映射、向量、数组等进行编写。只要你学习C++，就要按照你所知道的最好的方法去做。p> 好吧，如果你预先定义了一种情况，在这种情况下，
mycars
对象只包含法拉利和宝马汽车-你的代码是绝对正确的。例如，您可以：

Car*GetBMW()
{
    return BMW
}

Car*GetFerrari()
{
    return Ferrari;
}

Car* bmw = mycars->getBMW();
Car* ferrari = mycars->getFerrari();

bmw->ChangeSpeed();
// etc.

但是你有十辆车。在这种情况下，
std:：vector
可能是一个更好的选择，尽管您可以通过汽车的数字ID来引用汽车

底线是在适当的C++中有很多方法来编写你想要的东西（这是一个幻象：）。您可以使用或不使用指针、智能指针或引用、映射、向量、数组等进行编写。只要你学习C++，就要按照你所知道的最好的方法去做。p> 这并不能回答您的问题，但设计可能会更好一些。与其拥有一个处理多种类型汽车的
Car
类，不如拥有一个基本
Car
类，并让其他汽车类型继承自该类

然后，
CarBuilder
类是一个所谓的类，它可以区分不同类型的汽车，但会向您返回一个
Car
实例

差不多

#include <iostream>
#include <memory>

class Car
{
public:
    Car() : speed(0) {}
    virtual ~Car() {}

    void setSpeed(int speed) { this->speed = speed; }
    int getSpeed() const { return speed; }

    virtual std::string getType() = 0;

private:
    int speed;
};

struct Ferrari : public Car
{
    std::string getType() { return "Ferrari"; }
};

class BMW : public Car
{
    std::string getType() { return "BMW"; }
};

class CarBuilder
{
public:
    enum CarType
    {
        Ferrari,
        BMW
    };

    static std::unique_ptr<Car> makeCar(const CarType type)
    {
        switch (type)
        {
        case Ferrari:
            return std::unique_ptr<Car>(new ::Ferrari);
        case BMW:
            return std::unique_ptr<Car>(new ::BMW);
        default:
            return nullptr;
        }
    }
};

int main()
{
    auto myCar = CarBuilder::getCar(CarBuilder::Ferrari);
    std::cout << "My car is a " << myCar->getType() << '\n';
}

#包括
#包括
班车
{
公众：
Car（）：速度（0）{}
虚拟~Car（）{}
void setSpeed（intspeed）{this->speed=speed；}
int getSpeed（）常量{返回速度；}
虚拟std:：string getType（）=0；
私人：
整数速度；
};
结构法拉利：公共汽车
{
std:：string getType（）{返回“Ferrari”；}
};
宝马级：公共汽车
{
std:：string getType（）{return“BMW”；}
};
卡比尔德级
{
公众：
枚举类型
{
法拉利
宝马
};
静态std:：unique_ptr makeCar（const CarType类型）
{
开关（类型）
{
凯斯法拉利：
返回std：：unique_ptr（新的：：法拉利）；
案例BMW：
返回std:：unique_ptr（new:：BMW）；
违约：
返回空ptr；
}
}
};
int main（）
{
auto myCar=CarBuilder:：getCar（CarBuilder:：法拉利）；
std:：cout这并不能回答您的问题，但设计可能会更好一些。与其使用单个
Car
类来处理多种类型的汽车，不如使用一个基本
Car
类，并让其他汽车类型继承自该类

然后，
CarBuilder
类是一个所谓的类，它可以区分不同类型的汽车，但会向您返回一个
Car
实例

差不多

#include <iostream>
#include <memory>

class Car
{
public:
    Car() : speed(0) {}
    virtual ~Car() {}

    void setSpeed(int speed) { this->speed = speed; }
    int getSpeed() const { return speed; }

    virtual std::string getType() = 0;

private:
    int speed;
};

struct Ferrari : public Car
{
    std::string getType() { return "Ferrari"; }
};

class BMW : public Car
{
    std::string getType() { return "BMW"; }
};

class CarBuilder
{
public:
    enum CarType
    {
        Ferrari,
        BMW
    };

    static std::unique_ptr<Car> makeCar(const CarType type)
    {
        switch (type)
        {
        case Ferrari:
            return std::unique_ptr<Car>(new ::Ferrari);
        case BMW:
            return std::unique_ptr<Car>(new ::BMW);
        default:
            return nullptr;
        }
    }
};

int main()
{
    auto myCar = CarBuilder::getCar(CarBuilder::Ferrari);
    std::cout << "My car is a " << myCar->getType() << '\n';
}

#包括
#包括
班车
{
公众：
Car（）：速度（0）{}
虚拟~Car（）{}
void setSpeed（intspeed）{this->speed=speed；}
int getSpeed（）常量{返回速度；}
虚拟std:：string getType（）=0；
私人：
整数速度；
};
结构法拉利：公共汽车
{
std:：string getType（）{返回“Ferrari”；}
};
宝马级：公共汽车
{
std:：string getType（）{return“BMW”；}
};
卡比尔德级
{
公众：
枚举类型
{
法拉利
宝马
};
静态std:：unique_ptr makeCar（const CarType类型）
{
开关（类型）
{
凯斯法拉利：
返回std：：unique_ptr（新的：：法拉利）；
案例BMW：
返回std:：unique_ptr（new:：BMW）；
违约：
返回空ptr；
}
}
};
int main（）
{
auto myCar=CarBuilder:：getCar（CarBuilder:：法拉利）；
std：：cout这并没有回答你的问题，但是设计