Puntero de miembro de datos anidados: ¿no es posible?

Question

La muestra de código reducido engañoso no hace nada útil sino dos asignaciones posteriores a un puntero de miembro de datos. La primera asignación funciona, la segunda da un error de compilación. Presumiblemente porque es un miembro anidado.

La pregunta sería: ¿Realmente no es posible dejar que un apuntador miembro apunte a un miembro anidado o me falta alguna sintaxis de fantasía allí?

struct Color { 
    float Red; 
    float Green; 
    float Blue; }; 


struct Material { 
    float Brightness; 
    Color DiffuseColor; }; 


int main() { 
    float Material::* ParamToAnimate; 
    ParamToAnimate = &Material::Brightness;  // Ok 
    ParamToAnimate = &Material::DiffuseColor.Red; // Error! *whimper* 
    return 0; } 

ATM Estoy trabajando con el uso de compensaciones de bytes y una gran cantidad de moldes. Pero eso es feo, me gustaría usar esos indicadores de miembros.

Sí, sé que la pregunta seguramente surgió antes (como casi cualquier pregunta). Sí, busqué de antemano pero no encontré una respuesta satisfactoria.

Gracias por su tiempo.

Answer 1

AFAIK, esto no es posible. Un puntero a miembro solo puede estar formado por una expresión de tipo &qualified_id, que no es su caso.

La solución de Vite Falcon es probablemente la más adecuada.

Answer 2

Supongo que está tratando de obtener el puntero al miembro de datos Red. Como esto se define en la estructura Color, el tipo del puntero es Color::*. Por lo tanto, el código debe ser:

int main() { 
    float Color::* ParamToAnimate; 
    ParamToAnimate = &Color::Red; 
    return 0; } 

Para utilizarlo, es necesario para obligar a éste a una instancia de Color por ejemplo:

void f(Color* p, float Color::* pParam) 
{ 
    p->*pParam = 10.0; 
} 
int main() { 
    float Color::* ParamToAnimate; 
    ParamToAnimate = &Color::Red; 

    Material m; 
    f(&m.DiffuseColor, ParamToAnimate); 
    return 0; 
} 

EDITAR: ¿No es posible hacer la función de animación ¿una plantilla? Por ejemplo:

template<class T> 
void f(T* p, float T::* pParam) 
{ 
    p->*pParam = 10.0; 
} 
int main() { 

    Material m; 

    f(&m.DiffuseColor, &Color::Red); 
    f(&m, &Material::Brightness); 
    return 0; 
} 

Answer 3

Básicamente está tratando de obtener un puntero a una variable flotante que puede animar. Por qué no usar float*. El problema que tiene es que Brightness es miembro de Material, sin embargo, Red es miembro de Color y no Material, al compilador. El uso de float* debería resolver su problema.

Answer 4

En lugar de un puntero de miembro, puede usar un funtor que devuelve float* cuando se le da una instancia de Material; cambiar el tipo de ParamToAnimate a algo como:

std::function<float*(Material&)>

En el lado positivo, es portátil - pero a la baja, se requiere una cantidad significativa de código repetitivo y tiene significativa sobrecarga de tiempo de ejecución.

Si esto es crítico para el rendimiento, me sentiría tentado a seguir con el método de compensación.

Answer 5

Puede simplemente refactorizar de forma tal que no tenga la estructura anidada. Agregue un colocador que desempaquete el color en sus partes componentes para que el código existente no tenga que cambiar mucho y vaya desde allí.

También podría tomar un segundo puntero opcional que cava en el tipo anidado.Una sola prueba para ver si necesita el segundo parámetro puede ser lo suficientemente buena en comparación con su método actual, y se extendería más fácilmente si aparecen campos adicionales más adelante.

Da un paso más y tienes una clase base MaterialPointer con un método virtual Dereference. La clase de caso puede manejar miembros simples, con clases derivadas que manejan miembros anidados con la información adicional que necesitan para encontrarlos. Una fábrica puede producir MaterialMember* objetos del tipo apropiado. Por supuesto, ahora estás atascado con las asignaciones de montón, por lo que es probable que sea un poco demasiado lejos para ser práctico.

Answer 6

Dado que en algún momento se necesita un puntero a los datos reales, esto puede o puede no funcionar para usted:

float Material::* ParamToAnimate; 
ParamToAnimate = &Material::Brightness;  // Ok 
float Color::* Param2; 
Param2 = &Color::Red; 

Material mat; 
mat.Brightness = 1.23f; 
mat.DiffuseColor.Blue = 1.0f; 
mat.DiffuseColor.Green = 2.0f; 
mat.DiffuseColor.Red = 3.0f; 

float f = mat.DiffuseColor.*Param2; 

Answer 7

¿Qué hay de la herencia en lugar de composición?

struct Color { 
    float Red; 
    float Green; 
    float Blue; }; 

struct DiffuseColor : public Color { 
    }; 

struct Material : public DiffuseColor { 
    float Brightness; }; 


int main() { 
    float Material::* ParamToAnimate; 
    ParamToAnimate = &Material::Brightness;  // Ok 
    ParamToAnimate = &Material::DiffuseColor::Red; // Ok! *whew* 
    return 0; }