C ++ / CLI puntatore agli Stati

Question

Quali sono le varie opzioni per implementare un puntatore-a-membro costruire in C ++ / CLI?

Ho implementato alcuni algoritmi di geometria 2D che eseguono alcune azioni basate su X e coordinate Y. Trovo che sto spesso la duplicazione di codice una volta per l'asse X e una volta per l'asse Y. Un esempio è trovare i limiti massimo e minimo lungo ciascun asse.

Se fossi stato utilizzando nativo C ++, ho potuto usare un puntatore alla X o Y membro (larghezza anche, altezza e così via) e passato in un parametro in modo che devo realizzare ogni algoritmo sola volta. Ma con C ++ / CLI, questo non è possibile. Quali sono le opzioni? Sto cercando qualcosa di efficiente, leggero ed essenziale.

Answer 1

mi piacerebbe fare l'argomento di un argomento di tipo modello, invece, e utilizzare funtori che incapsulano l'accesso alle proprietà. Per esempio:.

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);

Naturalmente, questo ha senso solo se si dispone di un numero sufficiente di sufficientemente lunghi algoritmi per giustificare tutto il boilerplate. Sebbene gli involucri potrebbero essere generati e sia fatto riferimento tramite una macro, riducendo linee di codice un po '.

Answer 2

Opzione 1: se X e Y sono esposti come membri pubblici, li si potrebbe definire come parte di un'unione anonima, per esempio:

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

Questo consente di accedere X sia come shape.X o shape.point [0], e allo stesso modo, come shape.Y shape.point [1].

Opzione 2: Se X e Y sono esposti come proprietà, si potrebbe avere i loro getter / setter accedere a una gamma membro di due elementi, e quindi esporre la matrice come una proprietà di sola lettura troppo. Mentre il chiamante non può modificare la proprietà di matrice, si può ancora modificare i suoi elementi.

Opzione 3: bene, non è un'opzione, davvero. Non utilizzare .NET riflessione per accedere alle proprietà per nome. Il costo di esecuzione è troppo alto.