Переопределение статических переменных при разделении на подклассы

Возможно, вы сможете сделать вариант для микса или Любопытно повторяющегося шаблона

#include <stdio.h>

typedef const char QPainterPath;

class Base
{
public:
    virtual void paint() { printf( "test: %s\n", getPath() ); }
    virtual QPainterPath* getPath() = 0;
};

template <class TYPE>
class Holder : public Base
{
protected:
    static QPainterPath* path;
    virtual QPainterPath* getPath() { return path; }
};

class Data1 : public Holder<Data1>
{
};

class Data2 : public Holder<Data2>
{
};

template <> QPainterPath* Holder<Data1>::path = "Data1";
template <> QPainterPath* Holder<Data2>::path = "Data2";

int main( int argc, char* argv[] )
{
Base* data = new Data1;
data->paint();
delete data;

data = new Data2;
data->paint();
delete data;
}

Я только что запустил этот код в CodeBlocks и получил следующее:

test: Data1
test: Data2

Process returned 0 (0x0)   execution time : 0.029 s
Press any key to continue.

Я не протестировал это, но представление виртуальной функции:

struct Base {

    void paint() {
         APath * p = getPath();
         // do something with p
    }

    virtual APath * getPath() {
         return myPath;
    }

    static APath * myPath;
};

struct Derived : public Base  {

    APath * getPath() {
         return myPath;
    }
    static APath * myPath;
};

может быть тем, что Вы хотите. Обратите внимание, что все еще необходимо определить эти два помех где-нибудь:

APath * Base::myPath = 0;
APath * Derived::myPath = 0;

Вы можете использовать виртуальные функции для достижения вашего результата. Это, вероятно, ваше самое чистое решение.

class A
{
    protected:
        virtual QPainterPath *path() = 0;

    private:
        static QPainterPath *static_path;  /* Lazy initalization? */
};

QPainterPath *A::path()
{
    return A::static_path;
}

class F : public A
{
    protected:
        virtual QPainterPath *path() = 0;

    private:
        static QPainterPath *F_static_path;  /* Lazy initalization? */
};

QPainterPath *A::path()
{
    return F::F_static_path;
}

Вы не можете «переопределить» статические функции, не говоря уже о статических переменных-членах.

Что вам нужно, это, вероятно, виртуальная функция. Это могут быть только функции экземпляра, поэтому они не будут доступны без экземпляра класса.

Вы, вероятно, не хотите статических переменных к переопределенному. Возможно, можно ли сохранить указатель в классе вместо этого?

class A
{
    public:
        A() :
            path(static_path)
        {
        }

    protected:
        A(QPainterPath *path)
            : path(path)
        {
        }

    private:
        QPainterPath *path;

        static QPainterPath *static_path;  /* Lazy initalization? */
};

class F : public A
{
    public:
        F() :
            A(F_static_path)
        {
        }

    private:
        static QPainterPath *F_static_path;  /* Lazy initalization? */
};

Если вас не волнует внешний вид, просто используйте A :: или F ::, предшествующий использованию пути, чтобы выбрать правильный, или если вам не нравится :: назовите их по-другому.

Другой вариант - использовать функцию, чтобы убрать это, например. virtual QPainterPath * GetPath () {return A :: path; } в A и QPainterPath * GetPath () {return F :: path; } в F.

Действительно, хотя эта проблема связана не с тем, как выглядит код, а с тем, как он выглядит, и, поскольку он действительно не меняет читаемость, я бы не стал беспокоиться об этом ...