Estructuras - Historial de revisiones

Erikcrane: /* Declaracion */

2013-03-22T14:25:30Z

Declaracion

← Revisión anterior		Revisión del 14:25 22 mar 2013
Línea 6:		Línea 6:
	= Declaracion =		= Declaracion =
	<pre>		<pre>
	struct nombre{~~<br/>~~		struct nombre{
	int variable1;~~<br/>~~		int variable1;
	long variable2;~~<br/>~~		long variable2;
	char variable3[40];~~<br/>~~		char variable3[40];
	};		};

Erikcrane en 16:00 6 mar 2013

2013-03-06T16:00:56Z

← Revisión anterior		Revisión del 16:00 6 mar 2013
Línea 184:		Línea 184:
	= Asignación de estructuras =		= Asignación de estructuras =
	Ver apartado en [http://c.conclase.net/curso/?cap=011#inicio Curso de C++ - con Clase]		Ver apartado en [http://c.conclase.net/curso/?cap=011#inicio Curso de C++ - con Clase]

	~~= Documentación =~~
	~~[http://c.conclase.net/curso/?cap=011#inicio Curso de C++ con clase]<br/>~~
	~~[http://www.elrincondelc.com/cursoc/cursoc14.html Curso de C - El Rincón de C]<br/>~~

Erikcrane: Protegió «Estructuras» (‎[edit=sysop] (indefinido) ‎[move=sysop] (indefinido))

2013-03-06T14:41:03Z

Protegió «Estructuras» (‎[edit=sysop] (indefinido) ‎[move=sysop] (indefinido))

← Revisión anterior	Revisión del 14:41 6 mar 2013
(Sin diferencias)

Erikcrane en 14:38 6 mar 2013

2013-03-06T14:38:01Z

← Revisión anterior		Revisión del 14:38 6 mar 2013
Línea 1:		Línea 1:
	= ~~Estructuras~~ =		= Definicion =
	~~== Definicion ==~~
	*Permiten agrupar diferentes tipos de datos: int, long, char, ...		*Permiten agrupar diferentes tipos de datos: int, long, char, ...
	*Cada elemento de la estructura se llama miembro		*Cada elemento de la estructura se llama miembro
	== Declaracion ==
			= Declaracion =
	<pre>		<pre>
	struct nombre{<br/>		struct nombre{<br/>
Línea 31:		Línea 32:
	En algunos compiladores es posible que se exiga poner antes de struct la palabra static.		En algunos compiladores es posible que se exiga poner antes de struct la palabra static.

	== Acceder a la información ==		= Acceder a la información =
	*Se utiliza el operador de selección (.) --> pedro.variable1		*Se utiliza el operador de selección (.) --> pedro.variable1

	== Punteros ==		= Punteros =
	=== Punteros a Estructuras ===		== Punteros a Estructuras ==
	*Se declara un estructura normalmente		*Se declara un estructura normalmente
	Al declarar el objeto se pone el para crear el puntero		Al declarar el objeto se pone el para crear el puntero
Línea 67:		Línea 68:
	</pre>		</pre>

	=== Punteros a Arrays de Estructuras ===		== Punteros a Arrays de Estructuras ==

	<pre>		<pre>
Línea 101:		Línea 102:
	</pre>		</pre>

	== Pasar Estructuras a Funciones ==		= Pasar Estructuras a Funciones =
	*Se pasan igual que las variables		*Se pasan igual que las variables
	<pre>		<pre>
Línea 124:		Línea 125:
	}		}

	== Funciones dentro de las estructuras ==		= Funciones dentro de las estructuras =
	*Aplicable a C++.		*Aplicable a C++.
	*Son funciones que manipulan los datos de dentro de la estructura.		*Son funciones que manipulan los datos de dentro de la estructura.
	=== Constructor ===
			== Constructor ==
	*Es una función sin retorno y con el mismo nombre que la estructura		*Es una función sin retorno y con el mismo nombre que la estructura
	*Los valores no iniciados con los constructores contendran "basura"		*Los valores no iniciados con los constructores contendran "basura"
Línea 153:		Línea 155:
	</pre>		</pre>

	=== Destructor ===		== Destructor ==
	*Es igual pero con el simbolo ~ delante.		*Es igual pero con el simbolo ~ delante.
	=== Funciones ===
			== Funciones ==
	*Se pueden incluir otras funciones que se declaran y definen como las funciones normales.		*Se pueden incluir otras funciones que se declaran y definen como las funciones normales.
	<pre>		<pre>
Línea 176:		Línea 179:
	</pre>		</pre>

	== Arrays de estructuras ==		= Arrays de estructuras =
	Funcionan como los demas arrays		Funcionan como los demas arrays

	== Asignación de estructuras ==		= Asignación de estructuras =
	Ver apartado en [http://c.conclase.net/curso/?cap=011#inicio Curso de C++ - con Clase]		Ver apartado en [http://c.conclase.net/curso/?cap=011#inicio Curso de C++ - con Clase]

	== Documentación ==		= Documentación =
	[http://c.conclase.net/curso/?cap=011#inicio Curso de C++ con clase]<br/>		[http://c.conclase.net/curso/?cap=011#inicio Curso de C++ con clase]<br/>
	[http://www.elrincondelc.com/cursoc/cursoc14.html Curso de C - El Rincón de C]<br/>		[http://www.elrincondelc.com/cursoc/cursoc14.html Curso de C - El Rincón de C]<br/>

Erikcrane: Página creada con «= Estructuras = == Definicion == *Permiten agrupar diferentes tipos de datos: int, long, char, ... *Cada elemento de la estructura se llama miembro == Declaracion ==

 ...»

2013-03-06T14:36:48Z

Página creada con «= Estructuras = == Definicion == *Permiten agrupar diferentes tipos de datos: int, long, char, ... *Cada elemento de la estructura se llama miembro == Declaracion == <pre> ...»

Página nueva

= Estructuras =
== Definicion ==
*Permiten agrupar diferentes tipos de datos: int, long, char, ...
*Cada elemento de la estructura se llama miembro
== Declaracion ==
<pre>
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.
</pre>
El objeto pedro es un struct de tipo nombre. 
 
Otra forma de declarar: 
<pre>
struct nombre{
int variable1;
long variable2;
char variable3[40];
}pedro;
</pre>
Para inicializar la variable pedro se hace como con los arrays,
<pre>
pedro = {2, 40, "hola"};
</pre>
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 "."
<pre>
//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 );
}
</pre>

=== Punteros a Arrays de Estructuras ===

<pre>
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
}
}
</pre>

== Pasar Estructuras a Funciones ==
*Se pasan igual que las variables
<pre>
void nombre_función ( struct nombre_de_la_estructura nombre_de_la variable_estructura ){
}
</pre>
*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:
<pre>
struct Punto {
int x, y;
Punto() {x = 0; y = 0;} // Constructor
} Punto1, Punto2;
</pre>
Forma 2:
<pre>
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;
}
</pre>

=== Destructor ===
*Es igual pero con el simbolo ~ delante.
=== Funciones ===
*Se pueden incluir otras funciones que se declaran y definen como las funciones normales.
<pre>
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;
}
</pre>

== Arrays de estructuras ==
Funcionan como los demas arrays

== Asignación de estructuras ==
Ver apartado en [http://c.conclase.net/curso/?cap=011#inicio Curso de C++ - con Clase]

== Documentación ==
[http://c.conclase.net/curso/?cap=011#inicio Curso de C++ con clase] 
[http://www.elrincondelc.com/cursoc/cursoc14.html Curso de C - El Rincón de C]