ich habe eine Frage, wie man am besten folgendes Problem löst (oder ggf. ganz anders macht).

Vielleicht am besten gleich Code, der das illustriert. Weitere Member, die hier nichts zur Sache tun, habe ich im Sinne eines Minimalbeispiels weggelassen:

struct BaseValue
{
	BaseValue(size_t res);
	BaseValue();
	virtual ~BaseValue();
	size_t resolution;
	std::vector<double> values;
};

struct DerivedValue : public BaseValue
{
	DerivedValue(size_t additionalParam, size_t res);
	DerivedValue();
	~DerivedValue();
	// resolution aus Basisklasse
	// values aus Basisklasse
	size_t addParam;
	std::vector<double>  paramvals;
};

struct BaseManagement
{
	BaseManagement();
	BaseManagement(std::vector<std::string> input);
	virtual ~Collection();
	size_t nbofentries;
	std::vector<BaseValue> entries;
	void someFunction(BaseValue foo);
};

struct DerivedManagement : public BaseManagement
{
	DerivedManagement(std::vector<std::string> input);
	~DerivedManagement();
	// nbofentries aus Basisklasse
	// entries aus Basisklasse
	size_t nbofparams;
	std::vector<DerivedValue> entries;  /// Hier ist das Problem:
// DerivedManagement hat ja dann zusätzlich den std::vector<BaseValue> entries
// aus der Basisklasse! Ich möchte aber, dass es hier nur einen
// std::vector<DerivedValue> gibt, der "entries" aus der Basisklasse ersetzt.
};

Wie kann man so eine Art "gekoppelte" Vererbung erreichen? Ich möchte, dass DerivedManagement auf der DerivedValue-Klasse aufsetzt, weiß aber nicht, wie ich die Vererbung des std::vector<BaseValue> entries überschreiben kann.

Oder ist das Design einfach Mist und ich sollte das ganz anders machen?

Viele Grüße vom
inharator

template<class T>
struct BaseManagement
{
    std::vector<T> entries;
};

struct DerivedManagement : public BaseManagement<DerivedValue>
{
};

struct AbstractManagement
{
    AbstractManagement();
    AbstractManagement(std::vector<std::string> input);
    virtual ~AbstractManagement();
    size_t nbofentries;
};

struct BaseManagement : public AbstractManagement
{
    BaseManagement(std::vector<std::string> input);
    ~BaseManagement();
    std::vector<BaseValue> entries;
    void someFunction(BaseValue foo);
};

struct DerivedManagement : public AbstractManagement
{
    DerivedManagement(std::vector<std::string> input);
    ~DerivedManagement();
    std::vector<DerivedValue> entries;
    void someFunction(DerivedValue foo);
};

@MichelRT: Auch wenn Dein Vorschlag für mich zu spät kam, ist es gut, auch eine zweite Lösungsmöglichkeit zu kennen.

Viele Grüße vom
inharator

Oder vor dem BaseManagement Template noch eine non-Template Basisklasse einziehen, die Dinge die vom konkreten Value-Type abhängig sind dann ggf. über virtuelle Funktionen an das BaseManagement Template delegiert.