Workaround for virtual static function functionality - c++

Question

Let's say I have a class:
class StateVector {
protected:
float* _v;
public:
StateVector():_v(new float[size()]) {}
virtual ~StateVector() { delete [] _v; }
virtual size_t size() = 0;
// ...
};
class PositionState : public StateVector {
public:
size_t size() { return 3; }
float* x() { return _v; }
};
class MovingState : public PositionState {
public:
size_t size() { return PositionState::size() + 3; }
float* v() { return _v + PositionState::size(); }
};
The intent here is to allow derived classes to specify the size of the state vector by overriding size(). (This information needs to be available to the constructor of StateVector, the base class which owns the underlying array).
However, this is less than ideal for a few reasons:
First, in this implementation, size() must/will be the same for all instances of a class. But in this factoring, there is nothing that prevents different instances of the same class from having different opinions about size().
Second, other classes need to generate an instance in order to query the appropriate size:
template <typename State>
class StateTransition {
Matrix<float> _m;
// constructor for Matrix takes #rows, #cols
StateTransition():_m(State().size(), State().size()) {}
// ...
};
This is silly, because for all States, size() will be the same. In this case, size() might be quite large, and in the constructor for StateTransition will (by constructing two States) allocate two arrays of that size and then immediately throw them away!
Finally, it is expected that each derived class will carry a superset of its base's state, so size() should never be smaller for base classes than for derived classes– but since we can't traverse the inheritance tree, I don't know of a way to enforce this programmatically. This is a secondary concern, but it would be nice if there were a clean way to handle it.
It would make the most sense to be able to write:
class StateVector {
float* _v;
StateVector:_v(new float[size()]) {}
virtual static size_t size() = 0;
};
class PositionState {
static size_t size() { return 3; }
// ...
};
// etc.
template <typename State>
class StateTransition {
Matrix<float> _m;
StateTransition():_m(State::size(), State::size()) {}
};
However, other answers here (and elsewhere) indicate that virtual static functions are not allowed (and some of them unhelpfully suggest that it "doesn't make sense" or "wouldn't be useful").
What is an idiomatic way to solve this problem, that makes it easy as possible for derived classes to follow the rules?

Answer 1

Although I'm not sure why you insist on using virtual functions and not numeric arguments passed to the constructor of the base class, there is a solution that involves virtual functions, but of a different class:
class StateVectorInfo {
public:
virtual int size() const = 0;
protected:
~StateVectorInfo () = default;
};
class PositionStateInfo : public StateVectorInfo {
PositionStateInfo (); // don't create other instances
public:
virtual int size() const;
static PositionStateInfo info; // single instance
};
PositionStateInfo PositionStateInfo::info; // a definition is needed
class StateVector {
float* _v;
public:
StateVector (const StateVectorInfo& info):
_v(new float[info.size()]) {
}
};