C++: listas de inicialización/convenciones de nomenclatura

Question

El siguiente código funciona en mi máquina, pero ¿es una buena práctica/está garantizado que funcione?

struct MyStruct { 
    MyStruct(int x, int y, int z) : 
     x(x), 
     y(y), 
     z(z) { 
    } 

    int x; 
    int y; 
    int z; 
}; 

Específicamente, ¿x (x) garantiza hacer lo que yo quiero? (es decir, ¿la variable en una lista de inicialización siempre mira al miembro de esa estructura/clase?)

No quiero usar guiones bajos iniciales o finales ya que x es un miembro público de la estructura.

Gracias!

Answer 1

Sí, eso está garantizado para hacer lo que usted espera.

Lo único que puede existir "fuera" de los paréntesis en una lista de inicializadores son las variables miembro. Y dentro del paréntesis, se aplican las reglas habituales; las variables locales ocultan las variables miembro

En cuanto a si es una buena práctica, bien, considere lo que sucede si elimina accidentalmente uno o más de los argumentos de la lista de argumentos del constructor. ¡El código aún compilará bien! Pero se romperá horriblemente en el tiempo de ejecución. Sin embargo, todavía uso este patrón con bastante frecuencia.

Answer 2

Sí, x (x) hace exactamente lo que quiere. x (x) es un nombre del miembro, y x (x) es un argumento formal.

Answer 3

Mientras que espera que lo que haces, imagina esta situación por extensión:

class MyStruct { 
public: 
    MyStruct(int x, int y, int z) 
    : x(x), 
     y(y), 
     z(z) 
    { } 
    int x() const; 
    int y() const; 
    int z() const; 

private: 
    int x; 
    int y; 
    int z; 
}; 

que no funcionará. Es por eso que prefijo a los miembros de mi clase con m_. Esto permite un código muy legible con una pista para el lector de que el identificador en cuestión es parte de la clase. Los identificadores sin prefijo son argumentos de funciones (como en la lista de inicializadores del constructor: m_x(x), o variables locales de funciones).