Transcript Lenguaje C++ Ana Lilia Laureano-Cruces Universidad Autónoma Metropolitana - Azcapotzalco Lenguaje C++: Ana Laureano_UAM-A.

Lenguaje C++
Ana Lilia Laureano-Cruces
Universidad Autónoma Metropolitana
- Azcapotzalco
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Introducción
• Bjarne Stroustrup, mediados de los 80s, los laboratorios
Bell de AT&T.
• Permite la manipulación de hardware y de memoria a
bajo nivel, esto es, manipulación de lenguajes
ensambladores a partir de un lenguaje de alto nivel.
• Es un lenguaje multi-paradigma: su estructura esta
basada en los TAD’s. Donde lo que utilizamos son las
interfaces de la librería.
• .h (interfaz) y .cpp (la implementación y la aplicación)
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Introducción
• Paso de la programación estructurada (C) a estilos de
abstracción de datos y orientación a objetos.
• No es un lenguaje puro orientado a objetos. Conserva
características del C y añade nuevos conceptos.
• Utiliza dos formas de abstracción: generalización
(jerarquía) y agregación (parte de)
• Reservación: cuarto, hotel, persona, fecha; Avión, y
Boing 747.
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Extensiones respecto al C
• No orientadas a objeto
– Mejoras en entrada/salida - streams
– Polimorfismo: sobrecarga de funciones y operadores
(tiempo de compilación) y clases derivadas y
funciones virtuales (tiempo de ejecución)
– Parámetros por defecto. Referencias
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Fundamentos
• C ++, es un superconjunto de C, continúa
siendo un conjunto de subrutinas o funciones,
siendo estas estrictas o procedimientos.
• Se pueden encontrar en diferentes archivos, y
cuentan siempre con la función MAIN, que
recibe el control inicialmente. Además de contar
con las librerías de funciones del compilador C
++.
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Elementos del programa
•
•
•
•
•
•
•
COMENTARIOS
// Comentario de una sola línea
/* Comentario multilínea */
BLOQUES DE CÓDIGO
{ Todos los bloques de código van entre corchetes }
FIN DE LINEA
Todas las instrucciones terminan con un punto y coma ;
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Tipo básico de datos
• Tipo de dato bool tiene dos valores
asociados true o false
• DECLARACIÓN DE UNA
VARIABLE
• <Tipo de dato> Nombre_variable;
• INICIALIZACION DE UNA
VARIABLE
• <Tipo de dato> Nombre_variable
= [valor];
• EJEMPLO:
• int variable1;
• bool variable2=true;
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Tipo básico de datos
• Variables y aritmética.
• Todo nombre y/o expresión tiene un tipo.
• El tipo determina las operaciones que se pueden
realizar con el.
• Conversiones implícitas.
• En asignaciones y operaciones algebraicas el
lenguaje lleva a cabo todas las conversiones
implícitas que faciliten el uso y sean seguras.
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Fundamentos
• Declaración de constantes:
– CONST
• Tipos derivados
– Arreglos [ ]: comenzando con el índice 0.
– Apuntadores *: precede al identificador es una apuntador a
una localidad de memoria del tipo declarado, puede ser leído
o modificado su contenido.
– Referencias &: regresa la dirección de la variable.
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Arreglos
• Un arreglo es un conjunto de tipos de datos básicos
• DECLARACIÓN DE UN ARREGLO
• <Tipo de dato básico> Nombre_variable[Número de elementos];
• INICIALIZACION DE UN ARREGLO
• <Tipo de dato> Nombre_variable = {valor1, valor2, …, valorN};
• EJEMPLO:
• char arreglo1[10];
• float arreglo2 = {1.5, 2.3, 6,7};
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Arreglos Multidimencionales
• DECLARACIÓN DE UN ARREGLO
MULTIDIMENSIONAL
• <Tipo de dato básico> Nombre_variable[Número de
elementos][Numero de elementos];
• INICIALIZACION DE UN ARREGLO
MULTIDIMENSIONAL
• <Tipo de dato> Nombre_variable = { {valor1, valor2, …,
valorN}, {valor1, valor2, …, valorN} };
• EJEMPLO:
• char arreglo1[10][10];
• int arreglo2[ ]={{1,2,3},{4,5,6}{7,8,9}};
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
• Operadores y sentencias
– Sentencias
• Misma sintaxis y semántica que las de C
– Operadores idem sentencias excepto:
• new, delete, delete[ ], ::
• <<, >>
• Sobrecarga
Lenguaje C++: Ana Laureano_UAM-A
Interfaz (.h) Qué
Implementación (.cpp)
Cómo
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Fundamentos
•
•
•
•
•
Primer programa en C++
// pp1.cpp
# include < iostream.h>
main ( )
{
cout << “ hola mundo ” << endl;
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
//ejem1.cpp
#include<stdio.h>
#include<iostream.h>
main ( )
{
char Res;
int *p,q;
Res = 's';
while((Res=='s') ||(Res=='S')) {
•
•
•
q = 100; // se asigna 100 a la variable entera q
p = &q; //se asigna a p la direccion de q
printf ("%d", *p); // el contenido de p
•
•
•
•
•
cout << endl;
cout << "deseas desplegarlo de nuevo? (S/N) \n";
cin >> Res;
}
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
//este programa nos muestra el uso de las instrucciones para utilizar
//apuntadores
//pointer1.cpp
#include<iostream.h>
main(void)
{
int *p; //p es un apuntador a datos de tipo entero
p=new int; //asigna memoria para un entero
//simpre se debe verificar si la asignacion fue exitosa
if (!p){
cout<<"fallo la asignacion";
return 1;
}
*p=20; //asigna a esa memoria el valor de 20
cout<<"el valor depositado en la direccion apuntada por p es ";
cout<< *p; //prueba que funciona mostrando el valor
delete p; // libera la memoria
return 0;
}
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
• Scope (alcance)
– Fichero: declaraciones que no pertenecen a función
o clase alguna
– Función: etiquetas
– Local: cualquier nombre declarado en un bloque
pertenece al bloque.
– Clase: declaraciones asociadas a una clase
• Cada variable tiene un “scope” o un contexto
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Apuntadores y vectores
• Punteros y vectores.
char v[10]; //vector de 10 caracteres (0 a 9)
char *p; // puntero a un carácter
p = &v[3]; //p apunta al cuarto elemento de v
• punteros - operaciones asociadas
–
–
–
–
int *p; //puntero a entero
int **p; //puntero a puntero de entero
int (*vp) [10]; //puntero a vector de 10 enteros
int (*fp) ( char, char *);// puntero a función
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Tipos definidos por el usuario
• ESTRUCTURAS (Registros)
struct date_s {
int day, month, year;
} aDate;
La definición de arriba de aDate es también la
declaración de una estructura llamada date_s Podemos
definir otras variables de este tipo referenciando la
estructura por el nombre:
struct date_s AnotherDate;
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Tipos definidos por el usuario
• Enumeraciones
– enum_nombre {lista_de_elementos}
– Así como lo indica el formato a la lista de elementos
se le asignan valores enteros secuencialmente
iniciando por cero o los que el usuario asigne:
– enum colores { negro, rojo, verde, azul}
– enum colores { negro = 2, rojo, verde, azul}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
//Struct1.cpp
//este programa demuestra algunas maneras de accesar
//los elementos de una estructura
#include<stdio.h>
#include<conio.h>
struct s_tipo {
int i;
double d;
char str[80];
} s;
void main(void)
{
clrscr();
printf("Introduce un entero: ");
scanf("%d", &s.i);
printf("Introduce un numero de punto flotante: ");
scanf("%lf", &s.d);
printf("Introduce una cadena: ");
scanf("%s", &s.str);
printf("%d %lf %s", s.i, s.d, s.str);
}
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Estructuras de control de flujo
• EJEMPLO
• For (int i=0; i<5; i++)
• {
cout << “Hola mundo”<< i;
• }
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Operadores
Los operadores de incremento
++ y -- pueden ser
explicados por medio del
siguiente ejemplo. Si tienes la
siguiente secuencia de
instrucciones
a = a + 1; b = a;
Se puede usar
b = a++;
b = ++a;
Lenguaje C++: Ana Laureano_UAM-A
Paso de parámetros por valor y
por refrencia en C++
• En una abstracción funcional todos los
parámetros por default son por valor y la
función regresa un valor como resultado.
• En una abstracción procedural los parámetros
pueden pasar por valor y/o por referencia
Lenguaje C++: Ana Laureano_UAM-A
Paso de parámetros por valor en C++
#include <iostream.h> // paso por valores
void swap(int a, int b);
main( )
{int i = 421, j = 53;
cout <<"antes: i = " << i << " j = " << j << "\n";
swap(i,j);
cout <<"despues: i = " << i << " j = " << j << "\n";
}
void swap(int a,int b)
{int temp;
temp = a;
a = b;
b = temp;
cout <<"Al final y dentro de swap: i = " << a << " j = " <<
b << "\n";
}
Lenguaje C++: Ana Laureano_UAM-A
Paso de parámetros por referencia en C++
#include <iostream.h> // paso por referencias
void swap(int &a, int &b);
main()
{int i = 421, j = 53;
cout <<"antes: i = " << i << " j = " << j << "\n";
swap(i,j);
cout <<"despues: i = " << i << " j = " << j << "\n";
}
void swap(int &a,int &b)
{int temp;
temp = a;
a = b;
b = temp;
cout <<"Al final y dentro de swap: i = " << a << " j = " <<
b << "\n";
}
Lenguaje C++: Ana Laureano_UAM-A
Paso de parámetros por referencia en C++:
otra forma
#include <iostream.h> // paso por referencias
void swap(int *a, int *b); // a y b es una variable de tipo apuntador a entero
main()
{int i = 421, j = 53;
cout <<"antes: i = " << i << " j = " << j << "\n";
swap(&i,&j); // se pasan las direcciones de las localidades i y j
cout <<"despues: i = " << i << " j = " << j << "\n";
}
void swap(int *a,int *b)
{int temp;
temp = a;
a = b;
b = temp;
cout <<"Al final y dentro de swap: i = " << a << " j = " << b << "\n";
Lenguaje C++: Ana Laureano_UAM-A
//refer.cpp
// programa que ejemplifica el paso de parametros por valor
// y por referencia
# include <iostream.h>
int q, w;
void cambia(int x, int y)
{
int temp;
temp=x;
x=y;
y=temp;
}
void cambia1( int *a, int *b)
{
int t;
t = *a;
*a=*b;
*b= t;
}
main() {
cout<<"dame un valor entero";
cin>> q;
cout<<"Dame un valor entero ";
cin>> w;
cout<<"Escribo los valores antes de mandarlos";
cout<<"q= "<<q<<" "<<"w= "<<w<<endl;
cambia(q,w);
cout<<"escribo los valores despues de haberlos enviado a cambia";
cout<<q<<" "<<w<<endl;
cambia1(&q,&w);// intercambio de sus valores
cout<< "escribo los valores despues de haberlos enviado a cambia 1";
cout<<q<<" "<<w<<endl;
return 0;
}
Lenguaje C++: Ana Laureano_UAM-A
Clases de C++
• Las clases son consideradas
como una generalización de las
estructuras (struct).
• Las ventajas de las clases es
que pueden estar formadas por
partes privadas y por partes
públicas.
Lenguaje C++: Ana Laureano_UAM-A
Clases de C++
class Estructura {
public:
int posicion;
int cuantos;
char caracter;
};
Esta clase es equivalente a una estructura
Lenguaje C++: Ana Laureano_UAM-A
Clase Vs. Estructura
• Clase
• Estructura
– Todos los elementos
son privados.
– Pueden estar
formadas por partes
privadas y públicas.
– Todos sus elemntos
son públicos.
– Puede contener
funciones como
miembros.
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
//estruc.cpp
#include<iostream.h>
struct cl {
int obt_i(void);
// esto es publico
void poner_i(int j);
//por defecto
private:
int i;
};
int cl::obt_i(void)
{
return i;
}
void cl::poner_i(int j)
{
i=j;
}
main(void)
{
char Res;
Res='s';
cl s;
while ((Res=='s') || (Res=='S')) {
s.poner_i(10);
cout <<s.obt_i();
cout <<endl;
cout<<"deseas desplegarlo de
nuevo? (S/N) \n";
cin>> Res;
}
}
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
//clase.cpp
#include<iostream.h>
class cl {
int i;
//privado por defecto
public:
int obt_i(void);
void poder_i(int j);
};
int cl::obt_i(void)
{
return i;
}
void cl::poner_i(int j
{
i=j;
}
main(void)
{
char Res;
Res='s';
cl s;
while ((Res=='s') || (Res=='S')) {
s.poner_i(10);
cout <<s.obt_i();
cout <<endl;
cout<<"deseas desplegarlo de
nuevo? (S/N) \n";
cin>> Res;
}
}
Lenguaje C++: Ana Laureano_UAM-A
Clases de C++
// este programa crea y usa la clase punto
#include <conio.h>
class Punto
{ int x, y;
public:
Punto(int u, int v) { x=u; y=v; } // funcion constructora
void print() {gotoxy(x-4, y+1); cprintf("x=%2d y=%2d\r\n", x, y); }
void putch(char c) { gotoxy(x, y); ::putch(c); }
};
main()
// traza un punto y escribe sus coordenadas
{ clrscr();
Punto p1(20,6);
p1.putch('.');
p1.print();
}
Lenguaje C++: Ana Laureano_UAM-A
Las uniones en C++
• Las uniones sólo asignan espacio
suficiente para almacenar el campo de
mayor tamaño. (revisar el programa
union.cpp)
• Sus miembros son públicos.
• Puede contener funciones como
miembros.
• En C++, existe la unión anónima.
Lenguaje C++: Ana Laureano_UAM-A
La Unión anónima
• No tiene nombre, ni variables
especificadas en su decalaración.
• Los nombres de los miembros se acceden
directamente.
• No pueden incluir elementos privados o
protegidos.
Lenguaje C++: Ana Laureano_UAM-A
//unionmod.cpp
//programa que ejemplifica la union anonima
#include<iostream.h>
char Res;
main(){
Res='s';
while((Res=='s') || (Res=='S')) {
//esto declara una funcion anonima
union{ //sin nombre
int i;
char ch[2];
}; //no se especifica variables
/*ahora se hace referencia a: i y ch sin identificar
un nombre de union o los operadores punto o
flecha */
i=88;
cout<<i<<" " << ch[0];
cout <<endl;
cout<<"Desea desplegarlo de nuevo?
(S/N) ";
cin >> Res;
}
}
Lenguaje C++: Ana Laureano_UAM-A
Las clases y las estructuras
Pueden ser superclases de otras
clases y estructuras definidas
posteriormente; heredandoles sus
miembros. Las uniones quedan
excluidas de esta propiedad.
Lenguaje C++: Ana Laureano_UAM-A
Operador de resolución
ambito
• Para referenciar una variable global (:: i = 3)
• Para implementar una función miembro de
una clase
int c1::obt_i (void)
{
return i;
}
Lenguaje C++: Ana Laureano_UAM-A
Para manejo dinámico de
memoria (New y Delete)
• New:
– asigna memoria para un
objeto del tipo y tamaño
especificados.
– Devuelve un apuntador a
un objeto del tipo
especificado, que hace
referencia al espacio
reservado.
• Delete:
– libera la memoria
reservada para un objeto.
– Sólo se puede aplicar a
apuntadores que han sido
retornados por el operador
new.
Lenguaje C++: Ana Laureano_UAM-A
El manejo del tamaño en new
• En el caso de arreglos se especifica
explícitamente.
• En otros casos viene definido por el tipo.
• El tipo puede ser definido por el usuario.
Lenguaje C++: Ana Laureano_UAM-A
//programa que utiliza la asignacion de arrays utilizando new
//este programa realiza lo mismo que el anterior pero de una manera
//distinta
//array2.cpp
#include<iostream.h>
main(void)
{
float *p;
int i;
p=new float[10]; //obtiene un array de 10 elementos
if (!p) {
cout<<"fallo en la asignacion\n";
return 1;
}
// asigna valores de 100 a 109
for (i=0; i<10; i++) p[i]=100.00 +i; // asigna contenidos al array
for (i=0; i<10; i++) cout <<p[i]<<" "; // muestra los contenidos del array
delete [10] p; // borra el array completo
return 0;
}
Lenguaje C++: Ana Laureano_UAM-A
Constructores y
Destructores
• En otros lenguajes uno tiene que asegurar la
inicialización de los objetos.
• C++ los proporciona integrados a la sintaxis
del lenguaje.
• Su ejecución se realiza sin invocarlos
explícitamente.
• Cuando se declara un objeto de un tipo de
clase que cuente con constructores, éstos se
ejecutan automáticamente.
Lenguaje C++: Ana Laureano_UAM-A
Constructores
• Es una función miembro especial de una clase que es
llamada automáticamente siempre que se declara un
objeto de esa clase.
• Su función es crear e inicializar un objeto de su clase.
• Como funciones miembro aceptan argumentos.
• Tiene el mismo nombre de la clase a la que pertence.
Lenguaje C++: Ana Laureano_UAM-A
Destructores
• Un objeto es destruido automáticamente al salir
del ámbito en el que ha sido definido.
• Pero si han sido creados con new, tienen
forzosamente que ser destruidos con delete.
• Tiene el mismo nombre que la clase precedido
por una ~.
• No tiene argumento y no es heredado.
Lenguaje C++: Ana Laureano_UAM-A
Constructores y Destructores
• // esto crea la clase cola
• class cola {
int c [100];
int ppio, fin;
• public:
•
cola (void); // constructor
•
~ cola (void); // destructor
•
void meter (int y);
•
int sacar (void);
}
Lenguaje C++: Ana Laureano_UAM-A
Constructores y Destructores
• cola::cola (void)
• {
ppio = fin = 0;
• }
• cola::~cola (void)
• {
• }
Lenguaje C++: Ana Laureano_UAM-A
Constructores
Parametrizados
• Permiten crear las mismas tipos de objetos pero con
diferentes identificadores.
• Permite identificar en un mismo programa a diferentes
objetos del mismo tipo (Ej. Cola1 de Cola2).
• Y almcenar diferentes objetos en ellas.
• Se logra pasando argumentos a la función constructora.
Lenguaje C++: Ana Laureano_UAM-A
Constructores
Parametrizados
• // esto crea la clase cola
• class cola {
int c [100];
int ppio, fin;
• public:
•
cola (int id); // constructor
•
~ cola (void); // destructor
•
void meter (int y);
•
int sacar (void);
}
Lenguaje C++: Ana Laureano_UAM-A
Constructores
Parametrizados
• // esta es la función constructora
• cola::cola (int id)
• {
ppio = fin = 0;
quien = id;
cout << “ cola” << quien << “inicializada \ n”;
• }
• Para pasar el argumento a las funciones constructoras, éstos deben ir a
continuación del nombre del objeto y encerrado entre paréntesis con el
siguiente formato:
– Tipo_clase var (lista de argumentos)
– Cola a (1), b(2) // crea dos objetos cola
Lenguaje C++: Ana Laureano_UAM-A
TAD Cola: Interfaz
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
//conspara.h
#include<iostream.h>
#include<conio.h>
//esto crea la clase cola
//DEFINICION
# define Max_long 100
class cola {
int c[Max_long];
int ppio, fin;
int quien; //guarda el numero de la cola ID
public:
cola(int id); //constructor
~cola(void); //destructor
void meter(int i);
int sacar(void);
void Enc_Elem(int busca);
};
Lenguaje C++: Ana Laureano_UAM-A
TAD Cola: Implementación
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
//Conspara.cpp
#include<b:\include\conspara.h>
//IMPLEMENTACION
//Esta es la funcion constructora
cola::cola(int id)
{
ppio = fin = 0;
quien = id;
cout << "cola" << quien << "inicializada\n";
}
//Esta es la funcion destructora
cola::~cola(void)
{
cout<< "cola" << quien << " destruida\n";
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
void cola::meter(int i)
{
if(ppio==Max_long) {
cout << "la cola esta llena\n";
return;
}
ppio++;
c[ppio] = i;
}
int cola::sacar(void)
{
if(fin==ppio){
cout <<"la cola esta vacia\n";
return 0;
else {
fin++;
return c[fin];
}
•
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
void cola::Enc_Elem(int busca)
{
int j, elem;
if(ppio==Max_long) {
cout << "la cola esta llena\n";
return;
}
j=ppio;
for(j=1; j<=ppio; j++){
elem=c[j];
if(elem==busca) {
cout << "El elemento se encontró en la cola: " << busca << "\n";
}
else {
if(j==ppio){
cout << "El elemento no se encontró en la cola \n";
}
}
}
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
//prinpara.cpp
//PROGRAMA PRINCIPAL
#include<b:\bin\conspara.h>
main(void)
{
char Res;
Res='s';
clrscr();
while ((Res=='s') || (Res=='S')) {
cola a(1), b(2); //crea dos objetos cola
a.meter(10);
b.meter(19);
a.meter(20);
b.meter(1);
a.Enc_Elem(2);
cout<<a.sacar()<<" ";
cout<<a.sacar()<<" ";
cout<<b.sacar()<<" ";
cout<<b.sacar()<<" \n";
cout<<"deseas desplegarlo de nuevo? (S/N) \n";
cin >> Res;
}
}
Lenguaje C++: Ana Laureano_UAM-A
Funciones y Clases Amigas
Una clase puede conceder a otra
funcion o clase privilegiada
acceso a sus zonas privadas.
Lenguaje C++: Ana Laureano_UAM-A
Por qué
Existen situaciones en las cuales dos clases deben
compartir una misma función, por razones de
eficiencia o reusabilidad. (ejemplo amiga.h y
amiga.cpp) ; en este caso accede a la
variable color que es parte privada de ambas
clases
Cuando dos diferentes clases tienen algo en común
que tienen que comparar.(ejemplo speed.cpp) ;
comparten la velocidad de los dos vehículos (camión y
automóvil)
Lenguaje C++: Ana Laureano_UAM-A
Referencias anticipadas a
clases
• Existen cuando se encuentran implicadas
funciones friend. (ejemplo Amiga.h y
speed.cpp).
• Si la función amiga tiene como parámetros
ambas clases.
• Es para que el compilador sepa que el
identificador pertenece a una clase.
Lenguaje C++: Ana Laureano_UAM-A
Cómo lograrlo
• Lo logra declarando expilícitamente a la
clase o función como AMIGA(friend).
• En cualquier parte privada o pública.
• Una función miembro de una clase puede
ser una función amiga de otra clase.
Lenguaje C++: Ana Laureano_UAM-A
Class cosa {
private:
int datos;
public:
friend void cargatest (cosa t, int x);
}
// Implementación de la función Amiga cargatest()
void cargatest (cosa t, int x)
{
t.datos=x;
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
//DEFINICION
//Amiga.h
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
class linea; // declaración vacía para que el código posterior sepa que es una clase
class recuadro{
int color; //Color del recuadro
int xsup, ysup; //Esquina superior izquierda
int xinf, yinf; //Esquina inferior derecha
public:
friend int mismo_color(linea l, recuadro b);
void pon_color(int c);
void definir_recuadro(int x1, int y1, int x2, int y2);
void mostrar_recuadro(void);
};
class linea{
int color; //Color de la linea
int xinicial, yinicial; //Inicio y Fin de linea
int lon; //longitud
public:
friend int mismo_color(linea l, recuadro b);
void pon_color(int c);
void definir_linea(int x, int y, int l);
void mostrar_linea(void);
};
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
//Amiga.cpp
#include<iostream.h>
#include<conio.h>
#include<b:\include\amiga.h>
//IMPLEMENTACION
//Proporciona un valor verdadero si la linea y el recuadro tienen el mismo color.
// no es miembro de ninguna clase
int mismo_color (linea l, recuadro b)
{
if(l.color==b.color) return 1; // color es una variable privada
return 0;
}
//Implementacion de las funciones miembro de las CLASES
void recuadro::pon_color(int c)
{
color = c;
}
void linea::pon_color(int c)
{
color = c;
}
void recuadro::definir_recuadro(int x1, int y1, int x2, int y2)
{
xsup = x1;
ysup = y1;
xinf = x2;
yinf = y2;
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
void recuadro::mostrar_recuadro(void)
{
int i;
textcolor(color);
gotoxy(xsup, ysup);
for(i=xsup; i<=xinf; i++) cprintf("-");
gotoxy(xsup, yinf-1);
for(i=xsup; i<=xinf; i++) cprintf("-");
gotoxy(xsup, ysup);
for(i=ysup; i<=yinf; i++){
cprintf("|");
gotoxy(xsup, i);
}
gotoxy(xinf, ysup);
for(i=ysup; i<=yinf; i++){
cprintf("|");
gotoxy(xinf, i);
}
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
void linea::definir_linea(int x, int y, int l)
{
xinicial = x;
yinicial = y;
lon = l;
}
void linea::mostrar_linea(void)
{
int i;
textcolor(color);
gotoxy(xinicial, yinicial);
for(i=0; i<lon; i++) cprintf("-");
}
Lenguaje C++: Ana Laureano_UAM-A
//prinamig.cpp
#include<b:\bin\amiga.h>
//PROGRAMA PRINCIPAL
main(void)
{
char Res;
recuadro b; // declaración de clases
linea l; // declaración de clases
Res='s';
clrscr();
while((Res=='s') || (Res=='S')){
b.definir_recuadro(10, 10, 15, 15);
b.pon_color(3);
b.mostrar_recuadro();
l.definir_linea(2,2,10);
l.pon_color(2);
l.mostrar_linea();
if(!mismo_color(l,b)) cout << "no son iguales";
cout << "\n Pulse una tecla";
getch();
//Ahora hacemos que linea y recuadro tengan el mismo color
l.definir_linea(2, 2, 10);
l.pon_color(3);
l.mostrar_linea();
if(mismo_color(l,b)) cout << "tiene el mismo color \n";
cout <<"deseas desplegarlo de nuevo? (S/N) \n";
cin >> Res;
clrscr();
}
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Speed.cpp
#include<iostream.h>
#include<conio.h>
class camion; // declaración vacía para que el código posterior sepa que es una clase
class automovil {
int pasajeros;
int velocidad;
public:
automovil(int p, int s) { pasajeros = p; velocidad = s; }
friend int mayor_velocidad(automovil c, camion t);
};
class camion {
int peso;
int velocidad;
public:
camion(int pe, int s) { peso = pe; velocidad = s; }
friend int mayor_velocidad(automovil c, camion t);
};
•
•
•
•
/* La función amiga toma un valor positivo si la velocidad del automóvil
es mayor que la del camión. Toma un valor igual a cero, si ambas velocidades
son iguales. Y finalmente, esta función toma un valor negativo, si
la velocidad del camión es mayor que la del automóvil*/
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
int mayor_velocidad(automovil c, camion t)
{
return c.velocidad-t.velocidad;
}
main(void)
{
char Res;
int t;
Res = 's';
clrscr();
while ((Res=='s') || (Res=='S')) {
automovil c1(4, 55), c2(6,120);
camion t1(900, 55), t2(1000, 65);
cout << "Comparando c1 y t1: \n";
t = mayor_velocidad(c1, t1); //aqui comparamos t1 y c1
if(t<0) cout <<"El camion va mas rapido. \n";
else if(t==0) cout <<"Ambos tienen la misma velocidad. \n";
else cout <<"El automovil tiene mayor velocidad. \n";
cout<<"deseas desplegarlo de nuevo? (S/N) \n";
cin >> Res;
}
}
Lenguaje C++: Ana Laureano_UAM-A
// speed1.cpp ; una forma diferente de utilizar a las funciones amigas
#include<iostream.h>
#include<conio.h>
class camion;
class automovil {
int pasajeros;
int velocidad;
public:
automovil(int p, int s) { pasajeros = p; velocidad = s; }
int mayor_velocidad(camion t);
};
class camion {
int peso;
int velocidad;
public:
camion(int pe, int s) { peso = pe; velocidad = s; }
friend int automovil::mayor_velocidad(camion t);
// la función amiga es declarada en la clase que quiere utilizarla
//aqui esta funcion es amiga de la clase automovil y
//miembro de la clase camion, por lo que utilizamos
//el operador de resolucion de ambito, para declarar dicha relacion
};
/* la función mayor_velocidad se declara como miembro de la clase automovil y es amiga de la
clase camion; y se tiene que utilizar el operador de resolución de ámbito :: para indicar que la
función es miembro de la clase*/
Lenguaje C++: Ana Laureano_UAM-A
int automovil::mayor_velocidad(camion t)
{
return velocidad-t.velocidad;
//Aqui como mayor_velocidad es miembro de la clase automovil,
//solamente el objeto camion debe ser pasado a ella.
}
main(void)
{
char Res;
int t;
Res = 's';
clrscr();
while ((Res=='s') || (Res=='S')) {
automovil c1(4, 55), c2(6,120);
camion t1(900, 55), t2(1000, 65);
cout << "Comparando c1 y t1: \n";
t = c1.mayor_velocidad(t1);
//aqui comparamos t1 y c1
if(t<0) cout <<"El camion va mas rapido. \n";
else if(t==0) cout <<"Ambos tienen la misma velocidad. \n";
else cout <<"El automovil tiene mayor velocidad. \n";
cout << "Comparando c2 y t2: \n";
t = c2.mayor_velocidad(t2);
//aqui comparamos t1 y c1
if(t<0) cout <<"El camion va mas rapido. \n";
else if(t==0) cout <<"Ambos tienen la misma velocidad. \n";
else cout <<"El automovil tiene mayor velocidad. \n";
cout<<"deseas desplegarlo de nuevo? (S/N) \n";
cin >> Res;
}
}
Lenguaje C++: Ana Laureano_UAM-A
Sobre funciones amigas
• IMPORTANTE:
– Una función amiga no está al alcance de la clase de la cual es amiga.
(esto es, no es miembro).
– No puede ser llamada usando la sintaxis de selección de miembro
(scope ::).
– Se utiliza la palabra reservada friend que debe preceder a la
declaración de la función.
– Al ser una función amiga de una clase puede acceder a los miembros
privados de la clase.
Lenguaje C++: Ana Laureano_UAM-A
Clases Amigas
La declaración amiga hace a
todas las funciones miembro de
esa clase amigas de otra.
Class x {
friend class y;
//…
};
Lenguaje C++: Ana Laureano_UAM-A
Herencia Sencilla
Es una forma en que una clase
hereda solamente de una clase.
Lenguaje C++: Ana Laureano_UAM-A
Vocabulario de Clases
• Una clase que es heredada, se llama
clase base o clase madre.
• Una clase que hereda se llama clase
clase derivada o clase hija.
• Los elementos de una clase pueden ser:
publicos, privados o protegidos.
Lenguaje C++: Ana Laureano_UAM-A
Un elemento: Public, Private,
Protected
• Public: puede ser accedido por cualquier
función del programa.
• Private: puede ser accedido por fucniones
miembro.
• Protected: es lo mismo que privado pero
además pueden ser accedido/s por
funciones miembro y amigas.
Lenguaje C++: Ana Laureano_UAM-A
Cuando una calse hereda de
otra
• Los elementos privados de la clase base
son inaccesibles a la clase derivada.
• Si se desea que las clases derivadas
tengan acceso a los elementos privados.
– Se debe declarar a los elementos privados
como protegidos.
Lenguaje C++: Ana Laureano_UAM-A
Acceso a Clases: público
Publico: todos los elementos publicos y
ptotegidos de la clase base se convierten
en publicos y protegidos de las clases
derivadas. Los privados permanecen
privados.
Lenguaje C++: Ana Laureano_UAM-A
Acceso a Clases:protegido
Protegido: todos los elementos
publicos y protegidos de la clase
base se convierten en elementos
protegidos de la clase derivada. Los
privados permanecen privados.
Lenguaje C++: Ana Laureano_UAM-A
Acceso a Clases : privado
Privado: todos los elementos
publicos y protegidos de la clase
base se convierten en elementos
privados de la clase derivada. Los
privados permanecen privados.
(ejemplo herencia.cpp)
Lenguaje C++: Ana Laureano_UAM-A
Clases Virtuales
• Las clases virtuales se utilizan cuando una clase base
es clase base de mas de una clase derivada. Lo anterior
con el fin de garnatizar que sólo se herede (comparta)
una clase base. Una clase virtual debe tener:
– Ningún constructor, o al menos
– Un constructor sin argumentos, o
– Un constructor en que todos sus argumentos tengan valores por
omisión.
• Cuando se construye un objeto de una clase derivada,
se aplican primero los constructores de la clase base
virtual.
Lenguaje C++: Ana Laureano_UAM-A
// verue.h
// programa que crea una clase para manejarla con herencia
// este programa define 2 campos y 4 operaciones exclusivas de la
// clase vehiculo_ruedas.
#ifndef __VERUE_H__
#define __VERUE_H__
class vehiculo_ruedas {
int ruedas;
int pasajeros;
public:
void est_ruedas (int num);
int obt_ruedas (void);
void est_pasaj (int num);
int obt_pasaj (void);
};
#endif
Lenguaje C++: Ana Laureano_UAM-A
//camion.h
// se crea una clase camion con un campo y 3 operaciones exclusivas
// de ella y por otro lado hereda las operaciones de la clase
// vehiculo_ruedas
#include <iostream.h>
#include "b:\include\verue.h"
class camion:virtual public vehiculo_ruedas {
int carga;
public:
void est_carga (int tamanio);
int obt_carga (void);
void mostrar (void);
};
Lenguaje C++: Ana Laureano_UAM-A
//auto.h
// programa que define a la clase auto, con un campo y 3 operaciones
// exclusivas de esta clase y por otro lado hereda las de
// vehiculo_ruedas
#include <iostream.h>
#include "b:\include\verue.h"
enum tipo {coche, camioneta, furgon };
class automovil: virtual public vehiculo_ruedas {
tipo tipo_coche;
public:
void est_tipo (tipo t);
tipo obt_tipo (void);
void mostrar (void);
};
Lenguaje C++: Ana Laureano_UAM-A
//verue.cpp
// verue.imp
// este programa implementa las funciones de la clase
// vehiculo_ruedas
#include "b:\include\verue.h"
void vehiculo_ruedas::est_ruedas (int num) {
ruedas = num;
}
int vehiculo_ruedas::obt_ruedas (void) {
return ruedas;
}
void vehiculo_ruedas::est_pasaj (int num) {
pasajeros = num;
}
int vehiculo_ruedas::obt_pasaj (void) {
return pasajeros;
}
Lenguaje C++: Ana Laureano_UAM-A
//camion.cpp
// camion.imp
// en esta seccion de programa se implementan las funciones
// de la clase camion.
#include "b:\include\camion.h"
void camion::est_carga (int num) {
carga = num;
}
int camion::obt_carga (void) {
return carga;
}
void camion::mostrar (void){
cout<<"ruedas: "<<obt_ruedas () << "\n";
cout<<"pasajeros: " <<obt_pasaj() <<"\n";
cout<<"capacidad de carga en pies cúbicos: "<<carga << "\n";
}
Lenguaje C++: Ana Laureano_UAM-A
•
•
•
•
•
•
•
•
•
•
•
•
•
//auto.cpp
// implementacion de las funciones de la clase auto
#include "b:\include\auto.h"
void automovil::est_tipo (tipo t) {
tipo_coche = t ;
}
tipo automovil::obt_tipo (void) {
return tipo_coche;
}
void automovil::mostrar (void) {
cout << "ruedas: " << obt_ruedas() << "\n";
cout << "pasajeros: " << obt_pasaj() << "\n";
cout << "tipo: " ;
Lenguaje C++: Ana Laureano_UAM-A
•switch (obt_tipo()) {
•
case camioneta:
•
cout << "camioneta \n";
•
break;
•
case coche:
•
cout << "coche \n";
•
break;
•
case furgon:
•
cout << "furgon \n";
•
break;
•
}
•}
Lenguaje C++: Ana Laureano_UAM-A
//autoycam.cpp
#include "b:\include\camion.h"
#include "b:\include\auto.h"
void main (void) {
camion c1, c2;
automovil a;
c1.est_ruedas (18);
c1.est_pasaj(2);
c1.est_carga(3200);
c2.est_ruedas (6);
c2.est_pasaj (3);
c2.est_carga (1200);
a.est_ruedas (4);
a.est_pasaj (6);
a.est_tipo (camioneta);
a.mostrar ();
c1.mostrar ();
c2.mostrar ();
}
Lenguaje C++: Ana Laureano_UAM-A
Sobrecarga de Funciones
• Esta función esta ligada con el concepto
de polimorfismo.
• Ejemplo una función que regrese la hora
actual y otra que regrese la hora después
de la media noche las dos en horas,
minutos y segundos.
• En este caso las dos hacen lo mismo y
nodeberían llamarse de forma diferente.
Lenguaje C++: Ana Laureano_UAM-A
• C ++ permite que los nombres de las
funciones se sobrecarguen (overload). Es
decir que la misma función tenga mas de
una función.
– Overload GetTime
– Void GetTime (long* ticks); // segundos a
partir de la media noche
– Void GetTime (int* horas, int* minutos, int*
segundos)
Lenguaje C++: Ana Laureano_UAM-A
• La primera línea le dice que esta sobrecargada,
esto es, que tiene varias definiciones y debe
aparecer antes que todas las declaraciones y
definicones de dicha función.
• Cuando se llama GetTime, el compilador
compara el número y tipo de los argumentos y
escoge la que concuerde con la llamada.
• Por este motivo todas las definiciones de una
función sobrecargada deben tener distinto
número o tipo de paráemetros.
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Sobrecarga de operadores
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &=
|= << >> >>= <<= == != <= >= && || ++ ->* -> , [ ] ( ) new new[ ] delete delete[ ]
No se sobrecargan:
::
.
.*
Lenguaje C++: Ana Laureano_UAM-A
Lenguaje C++
Sobrecarga de operadores
class complex {
double re, im;
public:
complex(double r, double i) : re(r), im(i){}
complex operator+(complex);
complex operator*(complex);
bool operator==(complex);
bool operator<(complex);
};
void f()
{
complex a(1, 3.1);
complex b(1.2, 2);
complex c = b;
if(a==b)
a = b + c;
b = b + c * a;
c = a * b + complex(1,2);
}
Lenguaje C++: Ana Laureano_UAM-A