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

Используйте виртуальный метод, чтобы получить ссылку на статическую переменную.

class Base {
private:
    static A *a;
public:
    A* GetA() {
        return a;
    }
};

class Derived: public Base {
private:
    static B *b;
public:
    A* GetA() {
        return b;
    }
};

Обратите внимание, что B здесь происходит от A. Потом:

void Derived::paint() {
    this->GetA() ...
}

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

#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;
}

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

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

Пример :

template <typename T>
struct Helper {
  static QPainterPath* path;
  static void routine();
}

// Define default values
template <typename T> QPainterPath* Helper<T>::path = some_default_value;
template <typename T> void Helper<T>::routine { do_somehing(); }

class Derived {};

// Define specialized values for Derived
QPainterPath* Helper<Dervied>::path = some_other_value;
void Helper<Dervied>::routine { do_somehing_else(); }

int main(int argc, char** argv) {
  QPainterPath* path = Helper<Derived>::path;
  Helper<Derived>::routine();
  return 0;
}

Плюсы:

• чистая, инициализация времени компиляции
• статический доступ (без инстанцирования)
• вы также можете объявить специализированные статические функции

Минусы:

• никакой виртуализации, вам нужен точный тип для получения информации

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

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

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

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:: перед использованием пути, чтобы выбрать правильный, или, если вам не нравится ::, назовите их по-другому.

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

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