C ++ / CLI Pointer aos Estados

Question

Quais são as várias opções para implementar uma construção ponteiro-para-membro em C ++ / CLI?

Eu tenho implementado alguns algoritmos de geometria 2D que realizam algumas ações com base em X e Y coordenadas. Eu acho que eu sou freqüentemente duplicação de código uma vez para o eixo X e uma vez para o eixo Y. Um exemplo é encontrar os limites máximos e mínimos ao longo de cada eixo.

Se tivesse sido usando C ++ nativo, que poderia ter utilizado um ponteiro para o membro X ou Y (também largura, altura e assim por diante) e passou-no como um parâmetro de modo que é necessário aplicar cada algoritmo apenas uma vez. Mas com C ++ / CLI, isso não é possível. Quais são as minhas opções? Eu estou procurando algo eficiente, leve e concisa.

Answer 1

Eu faria o argumento um argumento tipo de modelo em vez disso, e de uso functors que o acesso propriedade encapsular. Por exemplo:.

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

Claro, isso só faz sentido se você tem um número suficiente de algoritmos suficientemente longas para justificar todo o clichê. Embora os invólucros podem ser ambos gerados e referenciado através de uma macro, a redução de linhas de código um pouco.

Answer 2

Opção 1: se X e Y são expostos como membros públicos, você poderia defini-los como parte de uma união anônima, por exemplo:

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

Isso permite o acesso X como quer shape.X ou shape.point [0], e da mesma forma, shape.Y como shape.point [1].

Opção 2: Se X e Y são expostos como propriedades, você pode ter seus getters / setters acessar uma matriz de membro de dois elementos, e, em seguida, expor a matriz como uma propriedade só de leitura também. Enquanto o chamador não pode modificar a propriedade de matriz, ele ainda pode modificar os seus elementos.

Opção 3: bem, não é uma opção, realmente. Não use .NET reflexão para acessar as propriedades pelo nome. O custo de execução é muito alto.