Как использовать атрибуты C#-like в C++

Для атрибутов класса - да. Просто определите базовый класс с именем Attributes для хранения информации об атрибутах и ​​унаследуйте его от любого класса, которому требуются атрибуты. Вы можете запросить его, используя RTTI cast.

Но для атрибутов метода или параметра это практически не вариант.

C ++ 0x будет поддерживать ограниченные атрибуты. Но я сомневаюсь, что это поможет вам в вашем текущем проекте или даже в следующих нескольких проектах (их здесь не будет какое-то время).

Я отвечу, предполагая, что вы имеете в виду свойства, функцию, которую я часто желанный.

Вы можете как бы поддержать свойства. В целом это было бы немного сложнее. Но для разовых работ это может быть легко

class Foo
{
    class MyI_property
    {
    public:
        MyI_property( Foo* parent ) :
            m_parent(parent)
        { }

        // getter
        operator int( void )
        { return m_parent->get_i(); }

        // setter
        MyI_property& operator = ( int i )
        { m_parent->set_i(i); }

        // some other operators you might want to implement
        int* operator&( void );
        MyI_property& operator += ( int rhs );

    private:
        Foo* m_parent;
    };

public:
    Foo( void ) :
        MyI(this)
    { }

    MyI_property MyI;

private:
    int& get_i( void );
    void set_i( int i );
};

Foo f;

f.MyI = 10; // calls Foo::set_i
int i = f.MyI; // calls Foo::get_i
int j = 2 * f.MyI + f.MyI;

// could work with proper overloads in MyI_property
f.MyI += 20;
int& i = f.MyI;
int* i = &f.MyI;

Ради краткости я проигнорировал корректность const.

Атрибуты описывают метаданные. Вы можете сделать это «вручную», унаследовав от базового класса, который определяет репозиторий «описаний» для частей класса, таких как методы. Однако вам понадобятся имена частей во время компиляции.

class whatever
{
public:
    static map<string, string> attribute_repository;
}

Беда, вероятно, не стоит того ...

Идея о том, как «смоделировать» атрибут класса с помощью специализации шаблона:

#include <string>
#include <iostream>

// attribute classes: the default implementation returns some
// default values for the attributes properties
template<typename TheClass> 
struct Attribute1{
    static const int Value = 0;
};

template<typename TheClass> 
struct Attribute2{
    static const std::string Value(){
        return "";
    }
};

Реализация атрибутов по умолчанию будет выбрана компилятором для класса без атрибутов:

// define a type without attributes
struct ClassWithoutAttributes{
};

Если мы хотим применить атрибуты к классу, мы используем специализацию шаблона:

// define a type with attributes; we "simulate" the attributes     
// template specialization
struct ClassWithAttributes{
};

// template-specialize Attribute1 for the class we want to apply the
// attribute to...
template<>
struct Attribute1<ClassWithAttributes>{
    static const int Value = 1;
};

// template-specialize Attribute2 
template<>
struct Attribute2<ClassWithAttributes>{
    static const std::string Value(){
        return "SomeString";
    }
};

Мы должны применить (шаблон- specialize) атрибуты для каждого класса, к которому мы хотим их применить:

class Item{
};

template<>
struct Attribute1<Item>{
    static const int Value = 2;
};

Пример:

// how to use the fake attributes:
void main(){
    // no template specialization for "ClassWithoutAttributes" => the compiler picks up the "default" values
    std::cout << "Attribute1 for type 'ClassWithoutAttributes' : " << Attribute1<ClassWithoutAttributes>::Value << std::endl;
    std::cout << "Attribute2 for type 'ClassWithoutAttributes' : " << Attribute2<ClassWithoutAttributes>::Value() << std::endl;
    // here the compiler picks up the attribute classes specialized for "ClassWithAttributes"
    std::cout << "Attribute1 for type 'ClassWithAttributes' : " << Attribute1<ClassWithAttributes>::Value << std::endl;
    std::cout << "Attribute2 for type 'ClassWithAttributes' : " << Attribute2<ClassWithAttributes>::Value() << std::endl;
}

Таким образом, атрибуты «применяются» к классу, а не к экземпляру, как при множественном наследовании; в любом случае фундаментальное отличие состоит в том, что в этом случае атрибуты оцениваются во время компиляции, а не во время выполнения.

РЕДАКТИРОВАТЬ : изменен пример, чтобы показать, как применять несколько атрибутов к классу и как применять один и тот же атрибут для нескольких классов.

Мне было весело отвечать на этот вопрос; в любом случае, на этом этапе Я считаю, что лучший совет по этому поводу - не пытаться программировать на C ++, как если бы это был C #. В любом случае удачного кодирования!

Создайте препроцессор, который превращает атрибут, такой как синтаксис, в фактические свойства и методы.

Вы просите аспектно-ориентированное программирование? AspectC ++ в настоящее время является всего лишь исследовательским прототипом :( http://www.aspectc.org/

В примере MVC, на который вы ссылаетесь, атрибуты метода используются через отражение. Поскольку C ++ не имеет отражения, вы можете рассмотреть возможность использования вместо этого генерации кода: какого-то языка определения интерфейса и генератора, создающего код C ++. В этом сценарии вы можете добавить концепцию атрибута к своему языку интерфейса и заставить генератор преобразовывать атрибуты соответствующим образом.

Отличным примером являются буферы протокола Google : есть специальный .proto формат для определения сообщений, который, в частности, включает «опции» (концепция, очень близкая к атрибутам .net). Также существуют компиляторы для разных языков программирования, включая C ++. Последний генерирует файлы .h / .cpp для сообщений, описываемых форматом .proto.

Я прочитал статью на CodeProject об этой проблеме: Реализация C ++ свойства C # и индексатора с модификаторами доступа . Я считаю, что это то, что вам нужно.