proggen.org

Code: Alles auswählen

template <typename Type, typename Parent>
class property {

    protected:
        Parent* parent;
        Type (Parent::*getter)();
        void (Parent::*setter)(Type);
        
        Type get() {
            return (this->parent->*getter)();
        }
        void set(Type value) {
            (this->parent->*setter)(value);
        }
    
    public:
        property(Parent* parent, Type (Parent::*getter)(), void (Parent::*setter)(Type))
            : parent(parent)
            , getter(getter)
            , setter(setter) {
        }
        
        property<Type, Parent>& operator=(Type value) {
            this->set(value);
        }
        property<Type, Parent>& operator+=(Type value) {
            Type current = this->get();
            current += value;
            this->set(current);
        }
        property<Type, Parent>& operator-=(Type value) {
            Type current = this->get();
            current -= value;
            this->set(current);
        }
        property<Type, Parent>& operator*=(Type value) {
            Type current = this->get();
            current *= value;
            this->set(current);
        }
        property<Type, Parent>& operator/=(Type value) {
            Type current = this->get();
            current /= value;
            this->set(current);
        }
        
        // @todo: Weitere Operatoren: + - * /  == != <= => < >
        
        operator Type() {
            return this->get();
        }
};

Code: Alles auswählen

class Example2 {
    protected:
        int _value;
        
        int getValue() {
            return this->_value;
        }
        void setValue(int value) {
            if (value < -10) { value = -10; }
            if (value > 100) { value = 100; }
            this->_value = value;
        }

    public:
        // Deklaration der Property
        property<int, Example2> value;

        Example2()
            // Wert initialisieren
            : _value(0)
            // Property initialisieren
            , value(this, &Example2::getValue, &Example2::setValue) {
        }
};

// ----------------------------------------------------------------------------

int main() {
    Example2 e;
    e.value = 5;
    e.value *= 2;
    int i = e.value;
    std::cout << i << "\n";
}

Code: Alles auswählen

#include <stdio.h>

template< typename type, type (*get)( type in ) >
class readonly
{
  private:
    type operator =( type & rhs ) {}
  protected:
    type Data;
    
  public:
    explicit readonly( type data )
      : Data( data ) {}
      
    operator type () const
    { return get( Data ); }
};

template< typename type, type (*get)( type in ), type (*set)( type out )>
class readwrite : public readonly< type, get >
{
  public:
    readwrite( type data )
      : readonly< type, get >( data ) {}

    type operator =( type const & rhs )
    {
      return readonly< type, get >::Data = set( rhs );
    }
};

int int_get( int data )
{
  printf( "get int: %d\n", data );
  return data;
}

int int_set( int data )
{
  printf( "set int: %d\n", data );
  return data;
}

int main()
{
  readonly< int, int_get > ro( 1 );
  readwrite< int, int_get, int_set > rw( 4711 );
  
  int temp = ro;
  
//  ro = 4;   // geht nicht
  temp = rw;
  rw = 1234;
  
  printf( "----\n" );
  
  printf( "ro: %d, rw: %d", (int)ro, (int)rw );
};

Code: Alles auswählen

apoc:glocke xin$ g++ property.cpp 
property.cpp: In function ‘int main()’:
property.cpp:51: error: no match for ‘operator=’ in ‘ro = 4’
property.cpp:7: note: candidates are: type readonly<type, get>::operator=(type&) [with type = int, type (* get)(type) = int_get]
property.cpp:5: note:                 readonly<int, int_get>& readonly<int, int_get>::operator=(const readonly<int, int_get>&)
apoc:glocke xin$ g++ property.cpp 
apoc:glocke xin$ ./a.out 
get int: 1
get int: 4711
set int: 1234
----
get int: 1234
get int: 1