Как определить функции-члены класса [дубликаты]

, хотя отражение не поддерживается вне коробки в c ++, это не так сложно реализовать. Я столкнулся с этой замечательной статьей: http://replicaisland.blogspot.co.il/2010/11/building-reflective-object-system-in-c.html

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

нижняя строка - отражение может окупиться, если сделано правильно, и это вполне возможно в c ++.

Я думаю, что вы можете найти интересную статью «Использование шаблонов для отражения на C ++» Доминика Филиона. Это в разделе 1.4 из Game Programming Gems 5 . К сожалению, у меня нет моей копии со мной, но ищите ее, потому что я думаю, что она объясняет, о чем вы просите.

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

Во-первых, чтобы упростить и очистить его в препроцессоре, мы будем использовать типизированное выражение. Типированное выражение - это просто выражение, которое помещает тип в круглые скобки. Поэтому вместо записи int x вы напишете (int) x. Вот несколько полезных макросов, которые помогут с типизированными выражениями:

#define REM(...) __VA_ARGS__
#define EAT(...)

// Retrieve the type
#define TYPEOF(x) DETAIL_TYPEOF(DETAIL_TYPEOF_PROBE x,)
#define DETAIL_TYPEOF(...) DETAIL_TYPEOF_HEAD(__VA_ARGS__)
#define DETAIL_TYPEOF_HEAD(x, ...) REM x
#define DETAIL_TYPEOF_PROBE(...) (__VA_ARGS__),
// Strip off the type
#define STRIP(x) EAT x
// Show the type without parenthesis
#define PAIR(x) REM x

Далее мы определяем макрос REFLECTABLE для генерации данных о каждом поле (плюс само поле). Этот макрос будет вызываться следующим образом:

REFLECTABLE
(
    (const char *) name,
    (int) age
)

Таким образом, используя Boost.PP , мы перебираем каждый аргумент и генерируем такие данные:

// A helper metafunction for adding const to a type
template<class M, class T>
struct make_const
{
    typedef T type;
};

template<class M, class T>
struct make_const<const M, T>
{
    typedef typename boost::add_const<T>::type type;
};


#define REFLECTABLE(...) \
static const int fields_n = BOOST_PP_VARIADIC_SIZE(__VA_ARGS__); \
friend struct reflector; \
template<int N, class Self> \
struct field_data {}; \
BOOST_PP_SEQ_FOR_EACH_I(REFLECT_EACH, data, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

#define REFLECT_EACH(r, data, i, x) \
PAIR(x); \
template<class Self> \
struct field_data<i, Self> \
{ \
    Self & self; \
    field_data(Self & self) : self(self) {} \
    \
    typename make_const<Self, TYPEOF(x)>::type & get() \
    { \
        return self.STRIP(x); \
    }\
    typename boost::add_const<TYPEOF(x)>::type & get() const \
    { \
        return self.STRIP(x); \
    }\
    const char * name() const \
    {\
        return BOOST_PP_STRINGIZE(STRIP(x)); \
    } \
}; \

Что это такое, генерирует константу fields_n, которая является числом отражаемых полей в классе. Затем он специализируется на field_data для каждого поля. Он также поддерживает класс reflector, поэтому он может обращаться к полям, даже если они являются частными:

struct reflector
{
    //Get field_data at index N
    template<int N, class T>
    static typename T::template field_data<N, T> get_field_data(T& x)
    {
        return typename T::template field_data<N, T>(x);
    }

    // Get the number of fields
    template<class T>
    struct fields
    {
        static const int n = T::fields_n;
    };
};

Теперь, чтобы перебирать поля, мы используем шаблон посетителя. Мы создаем диапазон MPL от 0 до количества полей и получаем доступ к данным поля по этому индексу. Затем он передает данные поля посетителю, предоставленному пользователю:

struct field_visitor
{
    template<class C, class Visitor, class I>
    void operator()(C& c, Visitor v, I)
    {
        v(reflector::get_field_data<I::value>(c));
    }
};


template<class C, class Visitor>
void visit_each(C & c, Visitor v)
{
    typedef boost::mpl::range_c<int,0,reflector::fields<C>::n> range;
    boost::mpl::for_each<range>(boost::bind<void>(field_visitor(), boost::ref(c), v, _1));
}

Теперь на момент истины мы все вместе. Вот как мы можем определить класс Person, который можно отразить:

struct Person
{
    Person(const char *name, int age)
        :
        name(name),
        age(age)
    {
    }
private:
    REFLECTABLE
    (
        (const char *) name,
        (int) age
    )
};

Вот обобщенная функция print_fields, использующая данные отражения для итерации по полям:

struct print_visitor
{
    template<class FieldData>
    void operator()(FieldData f)
    {
        std::cout << f.name() << "=" << f.get() << std::endl;
    }
};

template<class T>
void print_fields(T & x)
{
    visit_each(x, print_visitor());
}

Пример использования print_fields с отражаемым классом Person:

int main()
{
    Person p("Tom", 82);
    print_fields(p);
    return 0;
}

Какие выходы:

name=Tom
age=82

И вуаля, мы только что реализовали отражение в C ++, менее чем в 100 строк кода.

Отражение не поддерживается C ++ из коробки. Это печально, потому что это делает защитное испытание болью.

Существует несколько подходов к отражению:

1. использует отладочную информацию (не переносимую).
2. Погрузите свой код с помощью макросов / шаблонов или другого исходного подхода (выглядит уродливым)
3. Измените компилятор, такой как clang / gcc, чтобы создать базу данных.
4. Использовать подход Qt moc
5. Boost Reflect
6. Точное и плоское отражение

Первая ссылка выглядит наиболее многообещающий (использует mod's to clang), второй обсуждает ряд методов, третий - другой подход с использованием gcc:

1. http://www.donw.org/rfl/
2. https://bitbucket.org/dwilliamson/clreflect
3. https://root.cern.ch/how / how-use-reflex

В настоящее время существует рабочая группа для отражения C ++. См. Новости для C ++ 14 @ CERN:

• https://root.cern.ch/blog/status-reflection-c

Редактировать 13/08/17: Поскольку исходный пост имел ряд потенциальных улучшений в отношении отражения. Ниже приводится более подробная информация и обсуждение различных методов и статуса:

1. Статическое отражение в двух словах
2. Статическое отражение
3. Конструкция для статического отражения

Однако в ближайшем будущем это не выглядит многообещающим по стандартизованному методу отражения в C ++ если в сообществе больше интереса к поддержке для размышлений на C ++.

Ниже приводится информация о текущем состоянии, основанном на обратной связи с последними встречами на C ++:

• Размышления о предложениях отражения

Редактировать 13/12/2017

Отражение похоже на перемещение к C ++ 20 или, более вероятно, к TSR.

• Зеркало
• Стандартное предложение зеркала
• Зеркальная бумага
• Herb Sutter - мета-программирование, включая отражение

EDIT: CAMP больше не поддерживается; доступны две вилки:

• Один из них также называется CAMP и основан на том же API.
• Ponder является частичной перезаписью и будет предпочтительнее, поскольку она не требует Boost; он использует C ++ 11.

---

CAMP является лицензированной библиотекой MIT (ранее LGPL), которая добавляет отражение на язык C ++. Для компиляции не требуется определенный шаг предварительной обработки, но привязка должна выполняться вручную.

В текущей библиотеке Tegesoft используется Boost, но есть также fork , используя C ++ 11, что больше не требует Boost .

Простым способом является использование оператора dynamic_cast<>(), который при присвоении неправильного типа возвращает NULL, поэтому вы можете легко перейти к базовому конкретному классу, проверяя значение указателя, если оно не NULL, литье было выполнено, и вы получили тип объекта.

Но это простое решение, и оно предоставляет только тип объектов, вы не можете спросить, какие у него методы, как в Java. Если вам нужно продвинутое решение, есть некоторые рамки на выбор.

Информация существует, но не в том формате, который вам нужен, и только если вы экспортируете свои классы. Это работает в Windows, я не знаю о других платформах. Использование спецификаторов класса хранения, как, например,:

class __declspec(export) MyClass
{
public:
    void Foo(float x);
}

Это заставляет компилятор строить данные определения класса в DLL / Exe.

В моей компании мы построили библиотеку, которая интерпретирует эти метаданные, и позволяет вам отображать класс без добавления дополнительных макросов и т. Д. В сам класс , Он позволяет вызывать функции следующим образом:

MyClass *instance_ptr=new MyClass;
GetClass("MyClass")->GetFunction("Foo")->Invoke(instance_ptr,1.331);

Это эффективно делает:

instance_ptr->Foo(1.331);

Функция Invoke (this_pointer, ...) имеет переменные аргументы. Очевидно, вызывая функцию таким образом, вы обходите такие вещи, как const-безопасность и т. Д., Поэтому эти аспекты реализованы как проверки времени выполнения.

Я уверен, что синтаксис может быть улучшен, и это только работает на Win32 и Win64. Мы обнаружили, что это действительно полезно для создания автоматических интерфейсов GUI для классов, создания свойств на C ++, потоковой передачи в XML и т. Д. И т. Д., И нет необходимости выводить из определенного базового класса. Если есть достаточный спрос, возможно, мы могли бы выбить его в форму для выпуска.

Проверьте Classdesc http://classdesc.sf.net . Он обеспечивает отражение в виде дескрипторов класса, работает с любым стандартным компилятором C ++ (да, как известно, он работает с Visual Studio, а также с GCC), и не требует аннотации исходного кода (хотя существуют некоторые прагмы для обработки сложных ситуаций ). Он находится в разработке уже более десяти лет и используется в ряде промышленных проектов.

Обновлено 24.2.2017

Раньше я анализировал поддержку использования # define и, как это рекомендуется в некоторых веб-статьях - я попал в определения, которые на Visual C ++ не работали одинаково по сравнению с используемым определением в gcc (например, в интернете это довольно часто называют «прогулкой по MSVC»). Кроме того, вы не сможете легко понять, что происходит за механизмом разработки / макрорасширения - довольно сложно отладить каждое расширение макросов.

Существует несколько способов обойти сложности определения расширения, одним из подходов является включение флага компилятора «/ P» (только для предварительного процесса в файл) - после этого вы можете сравнить, как открывается ваш определение вверх. (Раньше я также активно использовал stringfy operator (#))

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

https://sourceforge.net/p/testcppreflect/code/HEAD/tree/MacroHelpers.h

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

Я вспомнил рабочий пример кода и поместил его в качестве проекта sourceforge, можно скачать здесь:

https://sourceforge.net/p/testcppreflect/code/HEAD/tree/

Демо-код выглядит следующим образом:

#include "CppReflect.h"
using namespace std;


class Person
{
public:
    REFLECTABLE( Person,
        (CString)   name,
        (int)       age
    )

};

class People
{
public:
    REFLECTABLE( People,
        (CString) groupName,
        (vector<Person>)  people
    )
};


void main(void)
{
    People ppl;
    ppl.groupName = "Group1";

    Person p;
    p.name = L"Roger";
    p.age = 37;
    ppl.people.push_back(p);
    p.name = L"Alice";
    p.age = 27;
    ppl.people.push_back( p );
    p.name = L"Cindy";
    p.age = 17;
    ppl.people.push_back( p );

    CStringA xml = ToXML( &ppl );
    CStringW errors;

    People ppl2;

    FromXml( &ppl2, xml, errors );
    CStringA xml2 = ToXML( &ppl2 );
    printf( xml2 );

}

REFLECTABLE define использует имя класса + имя поля с offsetof - для определения того, в каком месте в памяти находится определенное поле. Я попытался подобрать терминологию .NET, насколько это возможно, но C ++ и C # отличаются друг от друга, поэтому это не от 1 до 1. Модель отражения всего C ++ находится в классах TypeInfo и FieldInfo для обеспечения времени, возможно расширить поддержку и метода , но я решил сохранить все просто.

Я использовал парсинг pugi xml для извлечения демонстрационного кода в xml и восстановления его обратно из xml.

Таким образом, вывод, созданный демо-код выглядит следующим образом:

<?xml version="1.0" encoding="utf-8"?>
<People groupName="Group1">
    <people>
        <Person name="Roger" age="37" />
        <Person name="Alice" age="27" />
        <Person name="Cindy" age="17" />
    </people>
</People>

Также возможно включить любую поддержку 3-го партийного класса / структуры через класс TypeTraits и спецификацию частичного шаблона - определить свой собственный класс TypeTraitsT, в аналогичном способ CString или int - см. пример кода в

https://sourceforge.net/p/testcppreflect/code/HEAD/tree/TypeTraits.h#l65

template <>
class TypeTraitsT<CString> : public TypeTraits
{
public:
    virtual CStringW ToString( void* pField )
    { 
        CString* s = (CString*)pField;
        return *s;
    }

    virtual void FromString( void* pField, const wchar_t* value )
    { 
        CString* s = (CString*)pField;
        *s = value;
    }
};

template <>
class TypeTraitsT<int> : public TypeTraits
{
public:
    virtual CStringW ToString( void* pField )
    {
        int* p = (int*) pField;
        return std::to_string(*p).c_str();
    }

    virtual void FromString( void* pField, const wchar_t* value )
    {
        int* p = (int*)pField;
        *p = _wtoi(value);
    }
};

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

Два отражённых решения, о которых я знаю из моих дней C ++:

1) Используйте RTTI, который предоставит вам бутстрап, чтобы вы могли создать свое отражение-поведение, если сможете получить все ваши классы, чтобы получить базовый класс «объект». Этот класс может предоставить некоторые методы, такие как GetMethod, GetBaseClass и т. Д. Что касается того, как эти методы работают, вам нужно вручную добавить некоторые макросы для украшения ваших типов, которые за кулисами создают метаданные в типе, чтобы предоставлять ответы на GetMethods и т. Д.

2) Другим вариантом, если у вас есть доступ к объектам компилятора, является использование DIA SDK . Если я правильно помню, это позволит вам открыть pdbs, который должен содержать метаданные для ваших типов C ++. Этого может быть достаточно, чтобы сделать то, что вам нужно. На этой странице показано, как вы можете получить все базовые типы класса, например.

Оба эти решения немного уродливы! Нет ничего похожего на немного C ++, чтобы вы оценили роскошь C #.

Удачи.

отсутствие встроенного отражения в C ++ - единственная причина, по которой современный C ++ не используется для веб-разработки (и не хватает ORM и других фреймворков)

Вы можете попробовать http: // www. extreme.indiana.edu/reflcpp/

[g0] Вам нужно посмотреть, что вы пытаетесь сделать, и удовлетворяет ли RTTI вашим требованиям. Я реализовал свое собственное псевдо-отражение для некоторых очень специфических целей. Например, я однажды хотел иметь возможность гибко настраивать то, что будет выводить симуляция. Потребовалось добавить некоторый шаблонный код к классам, которые будут выводиться: [/g0] [f1] [g1] Первый вызов добавляет этот объект в систему фильтрации, которая вызывает метод [f3], чтобы выяснить, какие методы доступны. [/g1] [g2] Затем, в файле конфигурации, вы можете сделать что-то вроде этого: [/g2] [f2] [g3] Посредством некоторой магии шаблонов, включающей [f4], это преобразуется в серию вызовов методов в время выполнения (когда файл конфигурации читается), так что это довольно эффективно. Я бы не советовал делать это, если вам действительно не нужно, но, когда вы это делаете, вы можете делать действительно классные вещи. [/G3]