Instituto
Politécnico Nacional
ESIME Culhuacán
Struct
Es un tipo de dato compuesto que permite almacenar un conjunto de datos
de diferente tipo (caracteres, números enteros, flotante etc.)
A cada uno de los datos o elementos almacenados dentro de una
estructura se les denomina miembros y éstos pertenecerán a un tipo de dato
determinado.
Recordemos que una estructura
define un tipo de dato, no una variable, lo que significa que no existe reserva
de memoria cuando el compilador está analizando la estructura. Posteriormente
habrá que declarar variables del tipo definido por la estructura para poder
almacenar y manipular datos.
Sintaxis:
nom_struct
{
datos_miembro;
}
Miembro1, miembro2
struct: es una palabra reservada de C que
indica que los elementos que vienen agrupados a continuación entre llaves
componen una estructura.
nom_estruct: identifica el tipo de dato que se describe y del cual se podrán
declarar variables. Se especifica entre corchetes para indicar su opcionalidad.
Miembro1, miembro2…: Son los
elementos que componen la estructura de datos, deben ser precedidos por el tipo_dato al cual pertenecen
La declaración de variables de un determinado tipo de estructura de datos se puede
realizar de dos modos:
Primera:
Incluir en la propia definición de la estructura
aquellas variables que se van a emplear en el programa. Esta declaración de
variables implica que el ámbito en el que éstas son reconocidas será el
mismo que el de la declaración del tipo de dato estructura.
En estos casos, y si no se van a
declarar más variables de este tipo de dato en otros lugares del programa, el nom_estruct es innecesario
Ejemplo: estructura primera forma:
struct ejemplo
{
int a;
float b;
char c [];
double d;
}
ejm1, ejm2;
Segunda: Definir el tipo de dato
estructura con un nombre determinado y declarar posteriormente las variables de
ese tipo de dato. Para ello la estructura se identificará con un nombre de
forma obligatoria.
Ejemplo estructura segunda forma:
struct ejemplo
{
int a;
float b;
char c [];
double
d;
};
struct
ejemplo ejm1,ejm2;
Un struct es una manera de juntar un grupo de variables en una estructura.
Cuando se crea un struct, se pueden crear varias instancias de este «nuevo» tipo de variable
que ha inventado. Por ejemplo:
struct ejemplo1
{
char c;
int i;
float f; Nota*: Este programa no hace nada,
double d; solo es ejemplo de la estructura
};
int main()
{
struct ejemplo1 e1, e2;
e1.c = 'a';
e1.i = 1;
e1.f = 3.14;
e1.d = 0.00093;
e2.c = 'a';
e2.i = 1;
e2.f = 3.14;
e2.d = 0.00093;
}
Uniones
clases y objetos
La
Sintaxis de la clase es:
Una unión es un tipo de datos derivado, como
una estructura, con miembros
que
comparten el mismo espacio de almacenamiento.
Una
variable de tipo unión puede contener (en momentos diferentes) objetos
de
diferentes tipos y tamaños.
Las
uniones proporcionan una forma de manipular diferentes clases de datos
dentro
de una sola área de
almacenamiento.
En
cualquier momento una unión puede contener un máximo de un objeto
debido
a que los miembros de una unión comparten el espacio de almacenamiento.
Una
unión se declara con el mismo formato de una struct.
Sintaxis:
Pueden
declararse más objetos del tipo de la unión en cualquier parte del
programa, de la siguiente forma:
union nom_union
{ La palabra clave unión es opcional en la declaración
datos_miembro de
objetos en C++. Aunque en C es obligatoria
}
Union_miembro;
Algunas veces tenemos estructuras que son elementos del mismo tipo, por
ejemplo X, Y, y Z todos enteros. Pero en determinadas circunstancias, puede
convenirnos acceder a ellos como si fueran un array: Coor[0], Coor[1] y Coor[2]. En este caso, la unión puede resultar útil:
struct
stCoor3D
{ int X, Y, Z;
}; Nota*: Con estas declaraciones, en nuestros programa
union
unCoor3D podremos
referirnos a la coordenada Y de estas dos
int Coor[3]; Punto.N.Y
} Punto.Coor[1]
Punto;
int main()
{
union
{
int a;
const char* p;
};
a = 1;
p = “abcd";
}
Este programa nos sirve de ejemplo
para ver el uso de las uniones con el struct, pero realmente no hace nada este
programa
#include <iostream> typedef unión sirve para que nuestro compilador pueda
using namespace std; detectar union y algunas veces es necesario para struct
typedef union
{
int
a;
int
b;
}
ejemplo;
int main ()
{
ejemplo
e1;
e1.a=100;
e1.b=100;
cout<<e1.a<<endl;
cout<<e1.b<<endl;
}
Este programa muestra los valores
“e1.a” y “e1.b”
Programa
que almacena el “valor.x” y “valor.y”, luego con la unión, sobrescribe
el valor anterior
#include <iostream>
using namespace std;
union numero
{
int
x;
double y;
};
int main ()
{
union numero valor;
//definimos variable union
valor.x=100; //coloca enteros dentro de la union
cout<<"coloca un valor en el miembro entero e imprime ambos
miembros"<<endl;
cout<<"int:"<<valor.x<<" double:"<<valor.y;
valor.y=100.0; //coloca
un double dentro de la union
cout<<"\n\ncoloca un valor en el miembro flotante e imprime ambos miembros"<<endl;
cout<<"int:"<<valor.x<<" double:"<<valor.y;
}
clases y objetos
La
clase es la unidad básica encapsulación en C++,
contiene elementos como los atributos (variables) y métodos (funciones)
La clase nos sirve para definir características
del objeto, el objeto puede ser cualquier cosa que nos servirá de “molde” para
poder hacer múltiples objetos con características similares.
Podemos
definir los atributos y métodos comunes a los objetos de este tipo,
pero, cada objeto tendrá sus propios valores.
La
clase puede tener 3 tipos de encapsulamiento: privado (private), publico (public) y protegido (protected)
Por
defecto, los miembros de una clase suelen ser privados.
class nom_class
{
public:
<lista de miembros>
private:
<lista de miembros>
protected:
<lista de miembros>
};
Cuando
lleva un tipo de encapsulamiento, la llave que cierra la clase lleva " ; "
#include <iostream>
using namespace std;
class ejemplo
{
private:
int a; // Datos miembro de la
clase ejemplo
int
b;
public:
void Lee(int &a2, int &b2);
// Funciones miembro de la clase ejemplo
void Guarda(int a2, int b2)
{
a = a2;
b = b2;
}
};
void ejemplo::Lee(int &a2, int &b2)
//Se define fuera de la clase, se debe usar el operador de ámbito
"::"
{
a2 = a;
b2 = b;
}
int main()
{
ejemplo ejem1; //clase (ejemplo) y objeto (ejem1)
int x, y;
ejem1.Guarda(12, 32);
ejem1.Lee(x, y);
cout<<"Valor de ejem1.a: "<<x<<endl;
cout<<"Valor de ejem1.b: "<<y<<endl;
return 0;
}
Funciones
miembro
Las
variables de clase en C++ son datos de distinto tipo que sirven para describir
el estado actual de un objeto de esa clase. Se declaran al interior de una
clase de la misma forma en que se declaran variables en una aplicación convencional.
Los
métodos de una clase son funciones que sirven para manipular las variables de
la clase, dan pauta al encapsulamiento.
Los
métodos se declaran y definen de la misma manera que una función cualquiera en
una aplicación convencional de C++, dicho de otro modo, en su firma expresan el
tipo del valor de retorno, un nombre para el método y una lista de parámetros
de entrada.
La
sintaxis de las funciones es:
tipo_dato nom_funcion ( tipo_dato )
Ejemplos:
void main (void)
Int variable
(float a)
Se lee:
void main (void)
La
función llamada main ingresa void (vacio, nada) y regresa void
Int variable
(float a)
Función
variable, ingresa float a (flotante a) y regresa int
(entero)
La sintaxis para la declaración:
Tipo_dato clase,estructura o unión::identificador;
Esta
es una propiedad que nos será muy útil en la depuración de nuestras clases.
Además proporciona ciertos mecanismos necesarios para mantener la protección de
los datos.
Cuando
una función miembro no deba modificar el valor de ningún dato de la clase,
podemos y debemos declararla como constante. Esto evitará que la función
intente modificar los datos del objeto; pero como, a fin de cuentas, el código
de la función lo escribimos nosotros; el compilador nos ayudará generando un
error durante la compilación si la función intenta modificar alguno de los
datos miembro del objeto, ya sea directamente o de forma indirecta.
include <iostream>
using namespace std;
class Ejemplo
{
public:
Ejemplo(int a = 0) : A(a)
{
}
void ejem(int a)
{
A = a;
}
int Lee() const
{
return A;
}
private:
int A;
};
int main ()
{
Ejemplo X(6);
cout << X.Lee()<< endl;
X.ejem(2);
cout << X.Lee()<< endl;
return 0;
}
#include <iostream>
using namespace std;
class clase
{
public:
clase(int a, int b) : x(a), y(b)
{
}
int funcion(int a)
{
if(0 == a) return x; else return y;
}
private:
int x;
int y;
};
int main()
{
clase uno(6,10);
clase *dos = new clase(88,99);
int (clase::*pfun)(int);
pfun = &clase::funcion;
cout << (uno.*pfun)(0) << endl;
cout << (uno.*pfun)(1) << endl;
cout << (dos->*pfun)(0) << endl;
cout << (dos->*pfun)(1) << endl;
delete dos;
return 0;
}
Con
todo lo anterior podemos hacer muchas cosas, como crear clases anidadas como este programa:
#include <iostream>
#include <math.h>
using namespace std;
class base1
{
protected:
float pi;
int r;
int v;
};
class base2
{
protected:
int h;
};
class derivada:protected base1, protected base2
{
public:
float calculo();
void imprimir();
};
float derivada::calculo(void)
{
pi=3.15;
return((pi)*(r*r)*(h)); // v = pi *
r^2 * h
}
void derivada::imprimir ()
{
cout<<"ingresa radio"<<endl;
cin>>r;
cout<<"ingresa altura"<<endl;
cin>>h;
cout<<"el volumen es:"<<calculo()<<endl;
}
int main ()
{
derivada v;
v.imprimir();
}
Este
programa calcula el volumen de un cilindro con dos clases base y una derivada.
Una
clase base es para almacenar los datos del radio y la otra la altura, la clase
derivada calcula los datos del radio
Comentarios
Publicar un comentario