[C con Clase] Incluir una estructura privada dentro de una clase.

[Steven Davidson]

Hola Augusto,

Augusto wrote:

> Muy buenas!
> Necesito una manito con el tema de clases y estructuras.
> Necesito hacer una clase que almacene basicamente:
> 
> include<iostream>
> using namespace std;
> 
> class una{ 
> private:
>           struct uno{int mu; float su;};
>           struct dos{int md; float sd;}; 
>           char Nombre[100];  
> 
>  public: 
> //aca irian un par de variables y varias funciones...
> void funcion(){};
>          }; //fin class
> int main()
> {
> // desde main se llaman a las funciones de la clase "una".
> // la idea es instanciar 5 objetos "una" de las cuales cada una contiene:
> // un Nombre.
> // y
> // dos estructuras las cuales van almacenando datos que son ingresados por teclado.
> }
> 
> El problema esta en que no se como hacer para manejarme con las
> estructuras dentro de las funciones public o desde main.
> Supongo que debo manejarme con puntero, pero como los declaro?,
> donde?, en el contructor o en la funcion?
> La verdad que busque info en muchos libros y paginas, pero no
> encontre nada.

En primer lugar, debes declarar las variables de las estructuras en la 
clase 'una' para que sean miembros de tal clase. Por ahora, sólo has 
declarado 'Nombre' como el único dato miembro de 'una'. Si quieres más 
datos miembro de la clase 'una', entonces necesitas declararlos. Según 
la metodología de la POO, deberíamos definir los datos miembro en 
privado. Por lo tanto, escribimos,

clase una
{
private:
   char Nombre[100];
   uno unObj;
   dos dosObj;

public:
   ...
};

Si necesitas controlar la información de cada estructura directamente a 
través de un objeto de la clase 'una', entonces sólo necesitas proveer 
las funciones públicas de 'una' para tal control. Por ejemplo,

clase una
{
   ...
public:
   una();
   void asignarMu( int m )  { unObj.mu = m; }
   void asignarSu( float s )  { unObj.su = s; }
   ...
   int obtenerMu() const  { return unObj.mu; }
   float obtenerSu() const  { return unObj.su; }
   ...
};

De esta forma, nadie sabe que tienes dos estructuras como miembros en la 
clase 'una'.

Si no quieres esconder tanto, entonces puedes crear funciones miembro 
para enviar las estructuras miembro de la clase 'una'. Por ejemplo,

clase una
{
   ...
public:
   una();
   void asignarUno( const uno &obj )  { unObj = obj; }
   void asignarDos( const dos &obj )  { dosObj = obj; }
   ...
   uno obtenerUno() const  { return unObj; }
   dos obtenerDos() const  { return dosObj; }
   ...
};

Esto significa que la clase 'una' ofrece ciertos detalles internos de su 
clase. En este caso, cualquier código externo a esta clase puede 
manipular las dos estructuras. Sin embargo, esto también significa que 
debes dar a conocer la definición de tales estructuras 'uno' y 'dos'. 
Para esto, deberás definir las estructuras públicamente. Esto es,

class una
{
public:
   struct uno { int mu; float su; };
   struct dos { int md; float sd; };

private:
   uno unObj;
   dos dosObj;
   char Nombre[100];

public:
   ...
};

Ahora, por ejemplo, 'main()' puede acceder a cada tipo de la clase 'una' 
directamente, pero no puede acceder a cada variable de ambas 
estructuras. Por ejemplo,

int main()
{
   una::uno o1 = { 10, 4.5 };
   una::dos o2 = { -1, -.3 };

   una obj;
   obj.asignarUno( o1 );
   obj.asignarDos( o2 );

   cout << obj.obtenerUno().mu << ',' << obj.obtenerUno().su << endl;
   cout << obj.obtenerDos().md << ',' << obj.obtenerDos().sd << endl;

   return;
}

Como puedes ver, podemos acceder a cada estructura, pero sólo a través 
de las funciones miembro de la clase 'una'.


Espero haber aclarado las dudas.

Steven