C ++ / CLI pointeur vers un membre

Question

Quelles sont les différentes options pour mettre en œuvre un pointeur à membre Construct dans C ++ / CLI?

Je l'ai mis en œuvre des algorithmes de la géométrie 2D qui effectuent des actions basées sur X et Y coordonnées. Je trouve que je suis souvent la duplication de code une fois pour l'axe X et une fois pour l'axe Y. Un exemple est de trouver les limites maximale et minimale le long de chaque axe.

Si j'été en utilisant C ++ natif, je pu utiliser un pointeur vers l'élément X ou Y (largeur également, la hauteur et ainsi de suite) et transmis en tant que paramètre de telle sorte que je besoin de mettre en œuvre chaque algorithme qu'une seule fois. Mais avec C ++ / CLI, cela est impossible. Quelles sont mes options? Je cherche quelque chose efficace, léger et laconique.

Answer 1

Je fais l'argument un argument de type de modèle à la place, et d'utiliser foncteurs qui encapsulent accès à la propriété. Par exemple:.

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

Bien sûr, cela n'a de sens que si vous avez suffisamment nombreux algorithmes suffisamment longs pour justifier tout le passe-partout. Bien que les emballages puissent être à la fois générées et référencées par une macro, en réduisant les lignes de code un peu.

Answer 2

Option 1: si X et Y sont exposés en tant que membres du public, vous pouvez les définir dans le cadre d'une union anonyme, par exemple:

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

Cela vous permet d'accéder à X soit shape.X ou shape.point [0], et même, comme shape.Y shape.point [1].

Option 2: Si X et Y sont exposées en tant que propriétés, vous pourriez avoir leurs getters / setters accéder à un réseau de membres de deux éléments, puis exposer le tableau comme une propriété en lecture seule aussi. Bien que l'appelant ne peut pas modifier la propriété de tableau, il peut toujours modifier ses éléments.

Option 3: bien, pas une option, vraiment. Ne pas utiliser la réflexion .NET pour accéder aux propriétés par leur nom. Le coût d'exécution est trop élevé.