Rekursiver Typ Casting

Question

Ich habe eine typische 'vector4' Klasse mit einem Operator float *, um es autocasting für gl * 4fv sowie []. Es gibt auch ‚const‘ Version für Optimierungen für den Compiler sowie const refrences, und das funktioniert gut:

typedef struct vec4 
{ 
    ... 

    // ----------------------------------------------------------------- // 

     // Cast operator, for [] 
    inline operator float*() { 
     return (float*)this; 
    } 

     // Const cast operator, for const [] 
    inline operator const float*() const { 
     return (const float*)this; 
    } 

    // ----------------------------------------------------------------- // 

    ... 

     // Vertex/Vector 
    struct { 
     float x, y, z, w; 
    }; 

      // Color 
    struct { 
     float r, g, b, a; 
    }; 
} vec4; 

Mein Problem ist, wenn ich ein ‚MATRIX4‘ Klasse jetzt codiert, mit Bedienungs vec4 *, die unterstützt Extrahieren von Zeilen aus der Matrix, und haben auch den "Nebeneffekt" der Matrix [] [] Operator, was nett ist.

typedef struct mat4 
{ 
    ... 

    // ----------------------------------------------------------------- // 
      // Cast operator, for [] 
    inline operator vec4*() { 
     return (vec4*)this; 
    } 

     // Const cast operator, for const [] 
    inline operator const vec4*() const { 
     return (const vec4*)this; 
    } 
    // ----------------------------------------------------------------- // 

    private: 
     float f[16]; 
} mat4; 

Meine Frage ist, warum nicht der Compiler erkennt die Fähigkeit, eine MAT4 zu konvertieren * zu schweben? Ich würde vermuten, dass das Erbe von mat4 -> vec4 -> float * vernünftig ist, aber es scheint nicht so. Es kam mir in den Sinn, dass der Compiler es als MAT4 sehen könnte -> vec4 * -> float *, die nicht definiert ist, aber diese Annahme war ungültig, da

den Bediener definieren

inline operator const vec4() const { 
    return (vec4)*this; 
} 

nicht funktioniert, und Aufruf von glMultMatrixf (mat4 (...)); (Zum Beispiel) erzeugt die gleiche Fehlermeldung wie ohne den Operator.

definieren Operator float * in MAT4 ist natürlich unmöglich, denn das ist die Fähigkeit zu beseitigen [verwenden] [] (mehrdeutige Operatoren)

Irgendwelche Lösungen dafür? oder muss ich jedes Mal, wenn ich autocastieren möchte, manuell nach vec4 umwandeln? Auto-Casting ist ein wirklich nettes Feature und interpoliert den Code mit OpenGL sauber.

Answer 1

... Eine dieser Regeln ist, dass keine Folge von Umwandlungen darf enthalten mehr als eine benutzerdefinierte Konvertierung (dh ein Aufruf an einen einzelnen Argumentkonstruktor oder einen impliziten Typkonvertierungsoperator). - Effektiver C++, Scott Meyers

Sie könnten Operator [] für vec4 und mat4 überladen.

struct vec4 
{ 
    float& operator[](int index) { return f[index]; } 
    const float& operator[](int index) const { return f[index]; } 

    operator float*() { return f; } 
    operator const float*() const { return f; } 

    float f[4]; 
}; 

struct mat4 
{ 
    vec4& operator[](int row) { return v[row]; } 
    const vec4& operator[](int row) const { return v[row]; } 

    operator float*() { return f; } 
    operator const float*() const { return f; } 

    union 
    { 
     vec4 v[4]; 
     float f[16]; 
    }; 
}; 

int main(void) 
{ 
    mat4 m; 
    ::memset(&m, 0, sizeof(mat4)); 
    m[0][1] = 1; 
    cout << m[0][1] << endl; // it prints 1. 

    return 0; 
} 

Answer 2

C++ kann automatische Konvertierungen durchführen, führt aber standardmäßig keine zwei automatischen Konvertierungen durch.

Es wurde für unbeabsichtigte Bugs und Unklarheiten als zu günstig erachtet.

drei Optionen, die für Sie arbeiten können:

Explizit führen Sie das erste werfen Sie sich, wenn Sie eine float* aus einer Matrix wollen.

FuncThatWantsFloatPointer(*static_cast<Vec4*>(MyMatrix)); 

Implementieren eine direkte converstion zu float* in Ihrer Matrix-Klasse.

typedef struct mat4 
{ 
     ... 
     operator const float*() const 
     { 
       return *static_cast<Vec4*>(*this); 
     } 

} mat4; 

Implementieren operator[] in Ihrer Matrix und Vektor-Klassen, wenn Sie wie mit eckiger Klammer-Notation

typedef struct mat4 
{ 
     ... 
     const vec4& operator[] (size_t index) const 
     { 
       return static_cast<Vec4*>(*this)[index]; 
     } 

} mat4;