The resulting access class variable in a virtual function

Question

class Car { class BaseState { explicit BaseState(Car* vehicle) : mVehicle(vehicle) {} virtual void run() = 0; Car* mVehicle; } class State1 : public BaseState { explicit State1(Car* vehicle) : BaseState(vehicle) {} virtual void run() { // use data of Car ... doSomething(); } virtual void doSomething() { } } class State2 : public BaseState { } ... } class Convertible: public Car { class State1 : public Car::State1 { explicit State1(Convertible* vehicle) : Car::State1(vehicle) {} virtual void doSomething() { static_cast<Convertible*>(mVehicle)->foldTop(); } } class State2 : public Car::State2 { } ... void foldTop() {} } 

All states are made from BaseState, so they have an mVehicle member variable to access external class variables. However, in each derived class in all functions of each state, static_cast is required to access the variables and functions of members of the derived class.

The best solution?

• In each state of derived classes, add another pointer (for example, Convertible * mConvertible). Each state has double pointers (mConvertible and mVehicle) pointing to the same object. Doesn't look right.
• Use virtual Getter instead of mVehicle in base class. In the base class there will be excessive Getter calls.

==================================================== =======================

Yes. I tried the template as shown below, but it cannot be compiled because errors like

"car.h: In the member function" virtual void Car :: State1 :: run (): car.h: 18: 12: error: "mVehicle has not been declared in this area."

 // car.h #include <iostream> template <class T> class Car { public: class BaseState { public: explicit BaseState(T* vehicle) : mVehicle(vehicle) {} protected: T* mVehicle; }; class State1 : public BaseState { public: explicit State1(T* vehicle) : BaseState(vehicle) {} virtual void run() { mVehicle->x = 1; mVehicle->y = 2; mVehicle->doSomething1(); mVehicle->doSomething2(); processEvent(); } virtual void processEvent() { if (mVehicle->val > 2) { std::cout << "too large" << std::endl; } } }; class State2 : public BaseState { public: explicit State2(T* vehicle) : BaseState(vehicle) {} virtual void run() { mVehicle->x = 10; mVehicle->y = 20; processEvent(); } virtual void processEvent() { if (mVehicle->val > 20) { std::cout << "too large" << std::endl; } } }; virtual void doSomething1() { val += x * y; } virtual void doSomething2() { val += x + y; } protected: int x; int y; int val; }; // convertible.h #include "car.h" #include <iostream> class Convertible : public Car<Convertible> { protected: class State1 : public Car<Convertible>::State1 { explicit State1(Convertible* vehicle) : Car<Convertible>::State1(vehicle) {} // want to override functions in base class states virtual void processEvent() { if (mVehicle->val > 10) { std::cout << "too large" << std::endl; mVehicle->val = 10; } } }; // want to override some base class functions // and access some special variables // want to inherit other functions virtual void doSomething2() { z = 10; val += x + y + z; } protected: int z; }; 

If I use State1(Car* vehicle) instead of State1(T* vehicle) , there is an additional conversion error. What am I doing wrong?

If a program can determine that Convertible::State1::processEvent() should be executed, why can't it automatically distinguish mVehicle from Car* to Convertible* ? Apparently mVehicle points to a Convertible object when Convertible::State1::processEvent() . We do not need a template if there is an automatic cast.

Answer 1

This implementation does not use castes, duplicate pointers, virtual getters, or CRTP. It has three parallel hierarchies:

• cars
• abstract vehicle states that are pure abstract interfaces.
• The state of a particular vehicle, where the state is parameterized by the actual type of working vehicle type.

So we have, for example,

 Car Car::AbstractState Car::State<C> | | | +--- Convertible +--- Convertible::AbstractState +--- Convertible::State<C> | | | | | | | +--- Racer | +--- Racer::AbstractState | +--- Racer::State<C> +--- Hybrid +--- Hybrid::AbstractState +--- Hybrid::State<C> 

Each specific state occurs and implements the corresponding abstract state. If we have a Car* that points to Convertible , and we request its state, we get a Car::AbstractState* , which points to a specific state object with the final type Convertible::State<Convertible> . However, the user of the automotive hierarchy does not know and does not care about template cars.

Code:

 #include <iostream> using namespace std; struct Trace { Trace(const char* s) : s (s) { cout << s << " start\n"; } ~Trace() { cout << s << " end\n"; } const char* s; }; struct Car { struct AbstractState { virtual void run() = 0; }; template <typename C> struct State : virtual AbstractState { explicit State(C* vehicle) : mVehicle(vehicle) {} virtual void run() { Trace("Car::State::run"); doSomething(); }; virtual void doSomething() { Trace("Car::State::doSomething"); } C* mVehicle; }; virtual AbstractState* getState() { return new State<Car>(this); } }; struct Convertible : Car { struct AbstractState : virtual Car::AbstractState { virtual void runBetter() = 0; }; template <typename C> struct State : Car::State<C>, virtual AbstractState { using Car::State<C>::mVehicle; explicit State(C* vehicle) : Car::State<C>(vehicle) {} void doSomething() { Trace("Convertible::State::doSomething"); Car::State<C>::doSomething(); mVehicle->foldTop(); } void runBetter() { Trace("Convertible::State::runBetter"); run(); doSomethingElse(); }; virtual void doSomethingElse() { Trace("Convertible::State::doSomethingElse"); } }; void foldTop() { Trace("Convertible::foldTop"); } Convertible::AbstractState* getState() { return new State<Convertible>(this); } }; int main () { Car car; Convertible convertible; Car& car2(convertible); cout << "runing car\n"; Car::AbstractState* carstate = car.getState(); carstate->run(); cout << "runing convertible\n"; Convertible::AbstractState* convertiblestate = convertible.getState(); convertiblestate->run(); cout << "runing car2\n"; Car::AbstractState* carstate2 = car2.getState(); carstate2->run(); } 

Answer 2

Use patterns.

Remove pointer from Car inner classes (made them abstract classes full of pure virtual ones).

Add a new CarT template CarT (or think of a better name)

 template <typename T> class CarT { class CarHolder { explicit CarHolder(T* car) : car(car) {} T* car; }; class State1 : public Car::State1, protected CarHolder { explicit State1(Car* vehicle) : CarHolder(vehicle) {} virtual void run() { // use data of Car ... doSomething(); } virtual void doSomething() { } }; class State2 : public Car::State2 { }; ... }; 

This way you will have Car and State run-time polymorphism and good compile-time polymorphism of derived classes (which in turn will eliminate the need for ugly static_cast )

 class Convertible: public CarT<Convertible> { typename CarT<Convertible> Base; class State1 : public Base::State1 { explicit State1(Convertible* vehicle) : Car::State1(vehicle) {} virtual void doSomething() { car->foldTop(); } } class State2 : public Base::State2 { } ... void foldTop() {} } 

class Convertible : public CarT<Convertible> may seem strange, but it will work ( CarT uses the template argument only as a pointer, if he used it as a value element, there may be some problems)