Sprytny switch

class CFuzzySet
    : public ICFuzzySet
{
public:
    #ifdef __BORLANDC__
    typedef void( __closure * setter )( double );
    typedef double( __closure * getter )();
    virtual double param( std::string _name ) throw( EInvalidName );
    virtual TDName2Value params();
    virtual void setParam( std::string _name, double _val ) throw( EInvalidName );
    #endif
    virtual CFuzzySignal * parent() const { return FParent; }
    virtual void setParent( CFuzzySignal * _parent );
    virtual void setName( std::string _name ) throw( EInvalidName );
    virtual void setActivationLvl( double _y ) { FActivationLvl = _y; }
    virtual double activationLvl() const { return FActivationLvl; }
   
    virtual double boundedMembership( double _x );
protected:
    CFuzzySet();
    virtual ~CFuzzySet() { };
    virtual void reset() { FActivationLvl = 0.; }
    virtual void calculate( double _x );
    #ifdef __BORLANDC__
    std::map < std::string, setter > FSetters;
    std::map < std::string, getter > FGetters;
    #endif
    double FActivationLvl;
   
private:
    CFuzzySignal * FParent;
};

class CTrapezoid
    : public CFuzzySet
{
public:
    static ICFuzzySet * constructor();
    static const char * className() { return "trapezoid"; }
   
    virtual EnSetType type() const { return enFLstTrapezoid; }
    virtual double membership( double _x );
   
    double leftBottom() const { return FLeftBottom; }
    double leftTop() const { return FLeftTop; }
    double rightTop() const { return FRightTop; }
    double rightBottom() const { return FRightBottom; }
   
    void setLeftBottom( double _leftB );
    void setLeftTop( double _leftT );
    void setRightTop( double _rightT );
    void setRightBottom( double _rightB );
    #ifndef __BORLANDC__
    virtual double param( std::string _name ) throw( EInvalidName );
    virtual TDName2Value params();
    virtual void setParam( std::string _name, double _val ) throw( EInvalidName );
    #endif
   
private:
    CTrapezoid();
    virtual ~CTrapezoid() { };
   
    double FLeftBottom;
    double FLeftTop;
    double FRightTop;
    double FRightBottom;
};

CTrapezoid::CTrapezoid()
{
    #ifdef __BORLANDC__
    FGetters[ "left_bottom" ] = & leftBottom;
    FSetters[ "left_bottom" ] = & setLeftBottom;
   
    FGetters[ "left_top" ] = & leftTop;
    FSetters[ "left_top" ] = & setLeftTop;
   
    FGetters[ "right_top" ] = & rightTop;
    FSetters[ "right_top" ] = & setRightTop;
   
    FGetters[ "right_bottom" ] = & rightBottom;
    FSetters[ "right_bottom" ] = & setRightBottom;
    #endif
}

#include <iostream>
#include <vector>

#include <vcl.h>
#include <utilcls.h> // TVariant

#include <boost/bind.hpp>
#include <boost/function.hpp>

struct Prop
{
    std::vector < boost::function0 < TVariant > > getter;
   
    template < typename M, typename P >
    void add( M m, P * p )
    {
        getter.push_back( boost::bind( m, p ) );
    }
};

class Test
{
    AnsiString getString()
    {
        return "ala";
    }
    int getInt()
    {
        return 123;
    }
   
    Prop prop;
public:
    Test()
    {
        prop.add( & Test::getString, this );
        prop.add( & Test::getInt, this );
    }
   
    TVariant get( int c )
    {
        return prop.getter[ c ]();
    }
};

int main()
{
    Test t;
   
    AnsiString s = t.get( 0 );
    std::cout << s << std::endl;
   
    int i = t.get( 1 );
    std::cout << i << std::endl;
   
    return 0;
}