Существуют ли виртуальные статические методы ?
Кто — то их юзал ?

Здравствуйте, Аноним, Вы писали:

А>Существуют ли виртуальные статические методы ?

нет

А>Кто — то их юзал ?

как следствие их отсутствия, не юзал

Поясни свою мысль. Потому, что то сочетание твоих слов — ересь

Здравствуйте, Vamp, Вы писали:

V>Поясни свою мысль. Потому, что то сочетание твоих слов — ересь

Виртуальные методы класса — это методы экземпляра метакласса.

В Smalltalk метаклассы есть, в Delphi — неявно есть, а в C++ — нет (можно эмулировать).

Чаще всего виртуальные методы класса решают задачу паттерна Абстрактная Фабрика.

Здравствуйте, Аноним, Вы писали:

А>Существуют ли виртуальные статические методы ?

для виртуальности нужен объект (т.е. ее можно вызвать только для определенного объекта х твоего класса MyClass через x.virtual_f() или px->virtual_f()), а статическую функцию ты можешь позвать просто так: MyClass::static_f().

Отсюда вывод — нет.

You will always get what you always got
  If you always do  what you always did

К>Виртуальные методы класса — это методы экземпляра метакласса.
Не понимаю. О каком полиморфизме идет речь, если тип, для которого вызывается метод, указан?

К>В Smalltalk метаклассы есть, в Delphi — неявно есть, а в C++ — нет (можно эмулировать).
А как они используются? Любопытно для общего развития.

Здравствуйте, Vamp, Вы писали:


К>>В Smalltalk метаклассы есть, в Delphi — неявно есть, а в C++ — нет (можно эмулировать).
V>А как они используются? Любопытно для общего развития.
В Delphi VMT разбита на 2 части первая обычная с нулевым смещением хранит адреса виртуальных функций экземпляра класса, а вот с отрицательного смещения хранит адреса на информацию о типе и виртуальные методы Класса (виртуальные статические , object virtual) поэтому есть возможность создания виртуальных конструкторов, особенно это полезно при создании экземпляра по базовому типу, но вызываться будет конструктор наследуемого типа типу например переданнго как параметр, по примеру передачи объекта абстракного типа итд.
Очень полезная штука.

Кроме всего внутри базовых классов (Tobject) отрицательный значения VMT типа используется очень интенсивно.

Здравствуйте, Vamp, Вы писали:

К>>Виртуальные методы класса — это методы экземпляра метакласса.
V>Не понимаю. О каком полиморфизме идет речь, если тип, для которого вызывается метод, указан?
Вызывать же можно не только указывая явно тип
A::f()
Можно и через указатель
A *pa = ...;
pa->f();

Вот тут он мог-бы и чего-нибудь сделать, даже если f() статический.

Здравствуйте, Vamp, Вы писали:

К>>Виртуальные методы класса — это методы экземпляра метакласса.
V>Не понимаю. О каком полиморфизме идет речь, если тип, для которого вызывается метод, указан?

К>>В Smalltalk метаклассы есть, в Delphi — неявно есть, а в C++ — нет (можно эмулировать).
V>А как они используются? Любопытно для общего развития.

Примерно так: (на дельфях давно не играл, поэтому пример на С++)

class IObject
{
public:
  virtual ~IObject() {}

  class IMetaclass
  {
  public:
    virtual IObject* create() const = 0;
    virtual const char* name() const = 0; // пусть это будет не то же самое, что type_info::name()
    virtual int count() const = 0;
    virtual void inc() = 0;
  };

  virtual IMetaclass const* classof() const = 0;

  // методы метакласса должны быть и методами объекта
  // поэтому делаем шлюзы
  IObject* create() const { return classof()->create(); }
  const char* name() const { return classof()->name(); }
  int count() const { return classof()->count(); }
  void inc() const { return classof()->inc(); }

  // статические методы-шлюзы сделать централизованно не получится :(
  // разве что на шаблонах
};

///////////////////////////////////

class TheObject
{
public:
  class TheObjectMetaclass : public IMetaclass
  {
    int c_;
  public:
    virtual TheObject* create() const { return new TheObject(); }
    virtual const char* name() const { return "ТипаОбъект"; }
    virtual int count() const { return c_; }
    virtual void inc() { ++c_; }
  };
  static TheObjectMetaclass class_;
  virtual TheObjectMetaclass const* classof() const { return &class_; }
};

//////////////////////////////////

main()
{
  IMetaclass* meta = &TheObject::class_;

  ...

  // здесь мы не знаем о существовании типа TheObject... абстрактная фабрика в действии!
  IObject* obj = meta->create();

  ...

  obj->inc(); // работа со счётчиком именно TheObject, а не кого попало
  // может быть виртуальным методом объекта - а может быть методом метакласса (см. шлюзы выше)

  ...

  // а здесь мы не знаем о существовании экземпляров заявленного типа...
  cout << meta->count();
}

Ещё к метаклассам относятся (в С++) такие вещи, как type_info и dynamic_cast, то есть RTTI.

К>Примерно так: (на дельфях давно не играл, поэтому пример на С++)
Сделано, конечно, красиво.
Осталось указать где здесь виртуальное статическое.

Здравствуйте, <Аноним>, Вы писали:

К>>Примерно так: (на дельфях давно не играл, поэтому пример на С++)
А>Сделано, конечно, красиво.
А>Осталось указать где здесь виртуальное статическое.

Методы класса IMetaclass и TheObjectMetaclass.

Просто представь себе, что эти классы "спрятаны" — доступ к ним осуществляется напрямую, без прокси-методов

main()
{
    metaclass<IObject> *meta = classof<TheObject>();
    
    ...
    
    TheObject* obj1 = TheObject::create(); // невиртуальный вызов
    IObject* obj2 = meta->create(); // виртуальный статический
    IObject* obj3 = obj2->create(); // вызов метода класса как метода объекта
    // на самом деле, это вот что
    obj3 = classof(obj2)->create();
}

Увы, в С++ чтобы такую мечту реализовать — нужно изрядно попрыгать с бубном. Перед комитетом по стандартизации...

Здравствуйте, Кодт, Вы писали:

К>>>Примерно так: (на дельфях давно не играл, поэтому пример на С++)
А>>Сделано, конечно, красиво.
А>>Осталось указать где здесь виртуальное статическое.

К>Методы класса IMetaclass и TheObjectMetaclass.

По тексту они virtual, но не virtual static.

К>Просто представь себе, что эти классы "спрятаны" — доступ к ним осуществляется напрямую, без прокси-методов

В целом идея ясна. Для vcl у борланд есть TMetaClass, __classid и прочее.
Хотя если отбросить операцию взятия адресов функций, то остается задача получить по нечту статическому другое нечто имеющее класс производный от определенного базового. Которое при этом сможет вызвать ньюкало с конструктором заданного вида (в приведенном случае с конструктором по умолчанию). В mfc есть аналогичная муть на каких-то дичайших макросах.

А не кажется ли благородному собранию, что до произнесения слова "шаблон" остался один шаг?

August

Здравствуйте, Аноним, Вы писали:

А>А не кажется ли благородному собранию, что до произнесения слова "шаблон" остался один шаг?

Не совсем кажется. Шаблоны — это статический полиморфизм. Чтобы сделать динамический — придётся немножко попрыгать с напильником.

Хотя для основного набора методов (конструкторы, например) можно сделать заготовку.

К>Не совсем кажется. Шаблоны — это статический полиморфизм. Чтобы сделать динамический — придётся немножко попрыгать с напильником.

К>Хотя для основного набора методов (конструкторы, например) можно сделать заготовку.

Например такую:

#ifndef __meta_h
#define __meta_h

#include <loki/TypeManip.h>
#include <loki/static_check.h>


//Данная реализация метаклассов не компилируется Borland C++
//Только VC++ 7.1

template<class T>
class abstract_meta_class
{
protected:
  //Собственно метакласс, хранящий информацию о создаваемом объекте
  //В данном случае - абстрактный, для возможности создавать указатели
  //на метаклассы абстрактных классов, чтобы использовать их в качестве
  //общего знаменателя создаваемых объектов.
  //Вложенный защищённый класс, чтобы доступ к нему имели только наследники и
  //друзья
  class abstract_creator {
    class abstract_class_exception: public std::exception
    {
    public:
      const char* what() const { return "Нельзя создавать объект абстрактного класса"; }
    };
  public:
    virtual T* create() const { throw abstract_class_exception(); }
  };
  //объявляем друзьями все шаблонны этого типа, чтобы не делать открытых
  //функций доступа
  template<class U> friend class abstract_meta_class;
private:
  //указатель на реализацию. Может указывать на абстрактную и конкретную реализации.
  abstract_creator* creator;
  //Статическая копия реализации для данного типа T
  static abstract_creator creator_impl;

protected:
  //с помощью этого конструктора производные классы устанавливают свою
  //реализацию
  abstract_meta_class(abstract_creator* impl) { creator = impl; }

  //Функция присваивания из объекта метакласса ДРУГОГО типа.
  //Вызывается из конструкторов, операторов присваивания...
  //К сожалению, не нашёл возможности обойтись без reinterpret_cast.
  //Для контроля корректности приведения пришлось задействовать Loki
  template<class U>
  void set_creator(const abstract_meta_class<U>& other) {
     STATIC_CHECK(SUPERSUBCLASS(T,U),Source_Object_Type_Not_Derived);
     creator = reinterpret_cast<abstract_creator*>(other.creator);
  }
public:
  //конструктор по умолчанию
  abstract_meta_class() { creator = &creator_impl; }

  //конструктор копирования из объекта метакласса ДРУГОГО типа.
  template<class U>
  abstract_meta_class(const abstract_meta_class<U>& other) { set_creator(other); }

  //оператор присваивания из объекта метакласса ДРУГОГО типа.
  template<class U>
  abstract_meta_class<T>& operator = (const abstract_meta_class<U>& other) {
     set_creator(other);
     return *this;
  }

  //собственно создающая функция
  T* create() const { return creator->create(); }
};

template<class T>
typename abstract_meta_class<T>::abstract_creator abstract_meta_class<T>::creator_impl;

//Конкретный метакласс для типов, которые можно создавать
template<class T>
class meta_class: public abstract_meta_class<T>
{
protected:
  //метакласс, позволяющий создавать объекты
  class object_creator: public abstract_meta_class<T>::abstract_creator {
  public:
    virtual T* create() const { return new T(); }
  };
private:
  //статический экземпляр метакласса
  static object_creator creator_impl;
public:
  //конструктор
  meta_class(): abstract_meta_class<T>(&creator_impl) {}


  //конструктор копирования из объекта метакласса ДРУГОГО типа.
  template<class U>
  meta_class(const abstract_meta_class<U>& other): abstract_meta_class<T>(other) {}

  //оператор присваивания из объекта метакласса ДРУГОГО типа.
  template<class U>
  meta_class<T>& operator = (const abstract_meta_class<U>& other) {
     set_creator(other);
     return *this;
  }
};

template<class T>
typename meta_class<T>::object_creator meta_class<T>::creator_impl;

#endif

Пример использования

void main()
{
    abstract_meta_class<Base> meta = meta_class<MostDerived>();

    std::auto_ptr<Base> obj(meta.create());
    obj->Hello();
}

Здравствуйте, Аноним, Вы писали:

А>Существуют ли виртуальные статические методы ?
А>Кто — то их юзал ?

Статические функции не добавляются компилятором в карту виртуальных функций (vTable), потому не могут быть переопределены обычным образом.