Estructuras

De Proyectos
Saltar a: navegación, buscar

Definicion

  • Permiten agrupar diferentes tipos de datos: int, long, char, ...
  • Cada elemento de la estructura se llama miembro

Declaracion

struct nombre{
  int variable1;
  long variable2;
  char variable3[40];
};

struct nombre pedro; //En C es obligatorio usar la palabra struct en la declaracion de un objeto struct, en C++ no lo es.

El objeto pedro es un struct de tipo nombre.

Otra forma de declarar:

struct nombre{
  int variable1;
  long variable2;
  char variable3[40];
}pedro;

Para inicializar la variable pedro se hace como con los arrays,

pedro = {2, 40, "hola"};

Esto solo se usa en C, porque en C++ se pueden usar los constructores.

En algunos compiladores es posible que se exiga poner antes de struct la palabra static.

Acceder a la información

  • Se utiliza el operador de selección (.) --> pedro.variable1

Punteros

Punteros a Estructuras

  • Se declara un estructura normalmente
  • Al declarar el objeto se pone el * para crear el puntero
  • Para acceder a los miembros se utiliza el perador "->" en vez del el "."
//Se declara una estructura
struct estructura {
  char variable1[30];
  char varaible2[40];
  int entero;
};

//Se crea un objeto y se inicializa
struct estructura dato = {
 "hola",
 "adios",
 30
};

//Se declara un puntero
struct estructura *p_dato;

int main(){
  //Se apunta p_dato al objeto creado
  p_dato = &dato;

  printf( "%s\n", p_dato->variable1 );
  printf( "%s\n", p_dato->variable2 );
  printf( "%s\n" , p_dato->entero );
}

Punteros a Arrays de Estructuras

struct estructura {
  char variable1[30];
  char varaible2[40];
  int entero;
};

struct estructura dato[] = {
 "hola", "adios", 30,
 "perro", "casa", 20,
 "Coche", "moto", 4
};


struct estructura *p_dato;

int main(){

  //Se pueden usar estas dos formas para apuntar. Las dos significan lo mismo
  p_dato = dato;
  p_dato = &dato[0];

  int i;
  for(i=0; i<3; i++){
    printf( "%s\n", p_dato->variable1 );
    printf( "%s\n", p_dato->variable2 );
    printf( "%s\n" , p_dato->entero );
    p_dato ++ //Con esto avanzamos al siguiente elemento del array
  }
}

Pasar Estructuras a Funciones

  • Se pasan igual que las variables
void nombre_función ( struct nombre_de_la_estructura nombre_de_la variable_estructura ){
}
  • Al pasar la estructura a la función se hace mediante copia, es decir, que el valor original de un miembro de la estructura no cambia si dentro de la función lo modificamos
  • Se puede pasar la estructura mediante punteros
struct estructura {
 char variable1[30];
 char varaible2[40];
 int entero;
};
int main(){
 struct estructura dato = {"hola", "adios", 10};
 int numero;
 numero = sumale_10(&dato);
}
int sumale_10(struct estructura *dato){
 return dato->entero+10; //Ahora en vez de poner el operador "." se pone el "->"
}

Funciones dentro de las estructuras

  • Aplicable a C++.
  • Son funciones que manipulan los datos de dentro de la estructura.

Constructor

  • Es una función sin retorno y con el mismo nombre que la estructura
  • Los valores no iniciados con los constructores contendran "basura"
  • Se pueden definir varios constructores

Forma 1:

struct Punto { 
   int x, y; 
   Punto() {x = 0; y = 0;} // Constructor
} Punto1, Punto2;

Forma 2:

struct Punto { 
   int x, y; 
   Punto(); // Declaración del constructor
} Punto1, Punto2;
 
// Definición del constructor, fuera de la estructura
Punto::Punto() {  
   x = 0; 
   y = 0; 
}

Destructor

  • Es igual pero con el simbolo ~ delante.

Funciones

  • Se pueden incluir otras funciones que se declaran y definen como las funciones normales.
struct stPareja { 
   int A, B; 
   int LeeA() { return A;} // Devuelve el valor de A
   int LeeB() { return B;} // Devuelve el valor de B
   void GuardaA(int n) { A = n;} // Asigna un nuevo valor a A
   void GuardaB(int n) { B = n;} // Asigna un nuevo valor a B
} Par;
 
int main() { 
   Par.GuardaA(15); 
   Par.GuardaB(63); 
   cout << Par.LeeA() << endl; 
   cout << Par.LeeB() << endl;
 
   return 0; 
}

Arrays de estructuras

Funcionan como los demas arrays

Asignación de estructuras

Ver apartado en Curso de C++ - con Clase