Lenguaje C++ Ana Lilia Laureano-Cruces

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

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++: 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

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

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

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"; 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 Todos los elementos son privados. Pueden estar formadas por partes privadas y públicas. Estructura 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)
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]= 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

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

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

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

// 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<<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é Cuando dos diferentes clases tienen algo en común
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 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=ysup; i<=yinf; i++){ cprintf("|"); gotoxy(xsup, i); } gotoxy(xinf, ysup); 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); if(mismo_color(l,b)) cout << "tiene el mismo color \n"; cout <<"deseas desplegarlo de nuevo? (S/N) \n"; cin >> Res; } 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; camion(int pe, int s) { peso = pe; velocidad = s; } /* 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; 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 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

Es una forma en que una clase hereda solamente de una clase.
Herencia Sencilla Es una forma en que una clase hereda solamente de una clase. Lenguaje C++: Ana Laureano_UAM-A 1

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 2

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 3

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 4

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 5

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 5

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"; case furgon: cout << "furgon \n"; } 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

Lenguaje C++ Ana Lilia Laureano-Cruces

Presentaciones similares

Presentación del tema: "Lenguaje C++ Ana Lilia Laureano-Cruces"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Lenguaje C++ Ana Lilia Laureano-Cruces

Presentaciones similares

Presentación del tema: "Lenguaje C++ Ana Lilia Laureano-Cruces"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback