Acceder a la variable struct dentro del getter setter en una clase c ++

Question

Bien, tengo algo como esto en C ++:

class MyClass{
private:
  int someVariable;
  int someOtherVariable;

  struct structName{
    int someStructVariable;
    int someOtherStructVariable;
  };//end of struct

public:
  //getters & setters for the defined variables.

  int getSomeStructVariable()
  {
    // this does not work I get this error: "error: expected primary-expression
    // before '.' token"
    return structName.someStructVariable;
  } 
};//end of class

¿Cómo debo escribir mi getter o setter en este caso?

Answer 1

structName es parte del nombre del tipo, no el nombre de la variable. Debe darle un nombre, algo así como:

struct structName {
  int someStructVariable;
  int someOtherStructVariable;
} myStructure;

Y luego en su uso de acceso:

return myStructure.someStructVariable;

Eso debería darte el resultado que deseas. Otras alternativas para la variable de estructura son separar la definición de estructura de la declaración de variable:

struct structName {
  int someStructVariable;
  int someOtherStructVariable;
};

struct structName myStructure;

o para agregar typedef :

typedef struct structName {
  int someStructVariable;
  int someOtherStructVariable;
} structTypedefName;

structTypedefName myStructure;

Answer 2

struct A {
  A() : _n(0) {}
  int get_n() const {
    return _n;
  }
  void calculate(int a) {
    _n = a * a * a;
  }
private:
  int _n;
};

Aquí hay un ejemplo completo. Si desea un espejo set_n en lugar de algo que manipule los datos, entonces probablemente debería soltar el getter / setter (ya que los estaría usando incorrectamente) y hacer público el miembro de datos.

Además, recuerde: definir clases con struct funciona de forma idéntica para definir clases con class pero para una excepción: público en lugar de privado como acceso predeterminado para miembros y bases.

Answer 3

No es una buena idea escribir un captador / definidor para cada campo de estructura. Una mejor solución es:

typedef struct {
    int field1;
    int field2;
} structType;

class MyClass {
private:
    structType _structName;
public:
    const structType & getStructName() const {
        return _structName;
    }
}

Mantenga structType y MyClass separados. Utilice el captador como:

MyClass m;
int var;
var = m.getStructName().field1;

El primer const es necesario para devolver un valor const. El segundo es necesario para const-correctness .

Hay dos formas de definir un setter:

class MyClass {
// ...
public:
    // type 1
    void setStructName(const structType &s) {
        _structName = s;
    }
    // type 2
    structType & setStructName() {
        return _structName;
    }
}

Use el primero como:

MyClass m;
structType s;
m.setStructName(s);

La segunda versión también le permite modificar campos de estructura separados:

m.setStructName() = s;
m.setStructName().field1 = 10;

Tenga en cuenta que el colocador podría necesitar algunos ajustes si la estructura contiene punteros.