C ++ / CLI puntero a miembro

Question

¿Cuáles son las diversas opciones para implementar un puntero a miembro construyen en C ++ / CLI?

he implementado algunos algoritmos de geometría 2D que realizan algunas acciones basadas en X e Y coordenadas. Me parece que con frecuencia me la duplicación de código una vez para el eje X y otra para el eje Y. Un ejemplo es encontrar los límites máximos y mínimos a lo largo de cada eje.

Si hubiera estado utilizando C ++ nativo, podría haber utilizado un puntero a la X o miembro Y (también anchura, la altura y así sucesivamente) y se la pasó en como un parámetro de modo que necesito implementar cada algoritmo sólo una vez. Pero con C ++ / CLI, esto no es posible. ¿Cuáles son mis opciones? Busco algo eficiente, ligero y conciso.

Answer 1

Me gustaría hacer el argumento de un argumento tipo de plantilla en su lugar, y el uso de palabras funcionales que encapsulan acceso a la propiedad. Por ejemplo:.

ref class Point {
     property int X;
     property int Y;
};

struct Point_X_accessor
{
     static int get(Point^ p) { return p->X; }
     static int set(Point^ p, int value) { p->X = value; }
};

struct Point_Y_accessor
{
     static int get(Point^ p) { return p->Y; }
     static int set(Point^ p, int value) { p->Y = value; }
};

template <class PointAccessor>
int some_algorithm(Point^ p) { ... }

some_algorithm<Point_X_accessor>(p);
some_algorithm<Point_Y_accessor>(p);

Por supuesto, esto sólo tiene sentido si tiene muchos suficientemente suficientemente largos algoritmos para justificar todo el texto modelo. Aunque las envolturas pueden ser tanto generan y se hace referencia a través de una macro, la reducción en líneas de código un poco.

Answer 2

Opción 1: si X e Y son expuestas como miembros del público, se podría definir como parte de una unión anónima, por ejemplo:

class Shape {
public:
    union {
        struct { double X; double Y; };
        double point[2];
    };
    ...
};

Esto le permite acceder X, ya sea como shape.X o shape.point [0], y de manera similar, como shape.Y shape.point [1].

Opción 2: Si X e Y se exponen como propiedades, podría tener sus getters / setters acceder a un miembro del array de dos elementos, y luego exponer la matriz como una propiedad de sólo lectura también. Mientras que la persona que llama no puede modificar la propiedad de matriz, todavía puede modificar sus elementos.

Opción 3: Bueno, no es una opción, la verdad. No utilice .NET reflexión para acceder a las propiedades por su nombre. El coste de ejecución es demasiado alto.