INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELECTRICA

UNIDAD ZACATENCO

INGENIERIA EN COMUNICACIONES Y ELECTRONICA

LABORATORIO DE COMPUTACION

APUNTES DE CLASE

GRUPO: 2CM2

ALUMNO:

AlCANTARA SANCHEZ ALDO YAIR

PROFESORA:

GONZALEZ SANCHEZ AMERICA

Apuntes: tercera unidad

Apuntadores ó punterosSon variables que almacenan direcciones de memoria, su tamaño es de 4 bytes siempre en cualquier sistema operativo

Su declaración se da por:

char *apc; int *apc; float *apc; double *apc;

pueden ser direcciones de memoria de otras variables.

char c;

int x;

double w

1. cout<< apc; //F000 – dirección donde apunta2. cout<< &apc; //F00B – dirección de apc3. cout<< apc; // ’A’ – valor de donde apunta

Directriz, proporciona la dirección de la variable

[F001..F002]

char c c

[F000]

1 byte

c ‘A’

x

[F003..F00A]

w

apc=&c;

char c; ‘A’ apc

[F000] [F00B]char apc;

S.O, programas recidentes

Variables estáticas

Variables Dinámicas

Programas ejecutables

Total de la RAM

Programa Ulll_1#include<iostream>#include<conio2.h>using namespace std;int main(){char c,*apc; // se declara char el apuntador apcint x,*apx; // se declara entero el valor de apxclrscr();apc=&c; // proporciona la dirección de la variable*apc=’x’; //para cambiar el valor de c desde apcapx=&x; //se le asigna el valor de x a apcx=20; // para cambiar el valor de xcout<<”El valor de c= ”<<*apc<<endl; //imprime el contenido de apc cout<<”El valor de x= “<<*apx<<endl; //imprime el valor de apxgetch();return 0;}

Paso por DirecciónManda la dirección y recibe dirección.Ejemplo://Ulll_1_2 apuntador#include<iostream>#include<conio2.h>using namespace std;void imprime(char *apc){ cout<<"\nEl valor de c es="<<*apc; //imprimo el valor de c desde apc. }int main(){ char c, *apc; int x, *api; system("cls"); c='H'; api=&x; //apc apunta a la direccion de x *api=20; cout<<"El valor de c es="<<c; //imprimo desde c desde c imprime(&c); cout<<"\nEl valor de x es="<<x; //imprimo desde X desde X.

cout<<"\nEl valor de x es="<<*api; //imprimo el valor de X desde apc. getch(); return 0; }

Dos varibles y un apuntadorInt x,y, *ap;// *ap declara el apuntador

//direcciones

ap=&x; //pide la dirección de la variable xap=&y; // pide la dirección de la variable y

*ap= //pide el contenido de donde apuntaNota: un apuntador no puede apuntar a dos variables a la vez.

Dos variables y dos apuntadoresInt x,y *ap, *ap2;

Dos apuntadores pueden apuntar a una misma dirección.ap=&x;ap2=&y;ap=&y;

Programa Ulll_1_3#include<iostream>#include<conio2.h>using namespace std;

[FA00]

[F000]

x F

[FB00]

y

[FB00]

[FC00]

x 20

y

[FC00]

[FD00][FB00]

20

20

ap

ap

void imprime(int x, int y){ cout<<"\nEl valor de x es="<<x; //imprimo desde c desde c. cout<<"\nEl valor de y es="<<y; //imprimo desde c desde c. }void intercambio(int *apx, int *apy){ int aux; // se crea para poder intercambiar los datos de las variables aux=*apx; //se le asigna a aux el contenido de apx *apx=*apy; //se cambia el contenido de apx por el de pay *apy=aux; //se cambia el contenido de apy por el de aux }int main(){ int x, y, *apx, *apy; system("cls"); x=10; y=15; imprime(x,y); intercambio(&x,&y); imprime(x,y); getch(); return 0;}

Apuntadores a arreglos de datoschar name [20];

char *pname;

name

cin>>name; //entrada por el usuario

pname

para que apunte una caja a la vez se debe declarar: pname= &name[ 0 ];

A N A Φ [ F000 ]

Arquitectura de apuntadorespname=pname+1; ó pname++; //corrimiento de bytes a la derecha.

pname--; // corrimiento de bytes a la izquierda.

Programa Ulll_1_4#include<iostream>#include<conio.h>#include<stlib.h>using namespace std;class datos{char name[ 50 ],*pname;public:

Void pide();Void muestra();

};void datos::pide(){pname = &name[ 0 ];cout<<” Dame tu nombre: “;while(*pname = getch()!=’\r’)pname++;pname=’\0’; //para convertir el enter en nulo(porque es cadena de caracteres)}void

Programa Ulll_1_5_1//UIII_1_5 Palindromo#include<iostream>#include<conio.h>#include<cstring>//Me permite usar variables tipo toolusing namespace std;class datos{ char name[50],*pname; public: bool esPalin;//esPalin es una varible 1 o 0 (verdadera o falsa) int i,j; void pide(); void muestra(); void palindromo();

};void datos::pide(){ i=0; pname=&name[0]; cout<<"Dame tu nombre: \n"; while((*pname=getche())!='\r')//Pedimos el arreglo letra pr letra { pname++; i++; } *pname='\0'; j=i;}

void datos::muestra(){ system("cls"); cout<<"Mi nombre alreves es: "; while(i!=0) { pname--; cout<<*pname; i--; }}

void datos::palindromo(){ esPalin=true; for(int i = 0; i < j; i++) { if(tolower(name[i]) != tolower(name[j - 1 - i]))// { esPalin = false; break; } } if(esPalin) cout<<"\nEs palindromo.\n"; else cout<<"\nNo es palindromo.\n"; } int main(){ datos m;

m.pide(); m.muestra(); getch(); m.palindromo(); getch(); return 0;}

Asignacion dinamica de memoriaexisten 2 metodos para la asignacion de memoria dinamica

en C en C++

C C++

pedir malloc new

devolver free delete

Para pedir los datos:

char* pc: // es una cajita

pc= (char *) malloc(size of (char));// apunta a la direccion de malloc

*pc = “ para darle valor a pc”;

cout<<+pc;

free(pc); // para liberar el apuntador

Para un entero

Int *entero;

Entero = (int *) malloc (size of (int));

*entero = (10*2+15);

free(entero); //las variables dinámicas siempre deben devolver lo que usan

Arreglos de Datos Dinamicos: Int *v;v= (int *) malloc (sizeof (int)*5);*v = 5; v++ ; *v = 52;

free(v);

usando new:pc = new (char);*pc = ‘B’;delete (pc);

usando un entero:int * entero;entero = new(int);*entero = ------ ;delete (enetro);

Arreglos de datos dinamicos:Int * v;v= new int [];*v = ; v++;delete(v);

Apuntadores a EstructurasApuntadores a Structsstruct fecha{int d,m,a;} f , * pf; // se declara el apuntador después del nombre

Pf = &f; //pf esta apuntando a la caja fPf -> d //para cambiar el contenido de la caja dPf -> m // para cambiar el contenido de la caja mPf -> a // para cambiar el contenido de la caja a( * pf ).d // para cambiar el contenido de la caja a

UIII_6

sobrecarga de funciones de usuarioEs más de una función que se llama igual(el mismo nombre más de una vez). Como requisito debe haber una diferencia en los parámetros (diferentes tipos) ó en el tipo de la función.

Programa Ulll_7#include<iostream>#include<conio2.h>

using namespace std;class datos{ public:

datos(); //Función constructor datos( char *n);//Funcion constructor con parametros

}; datos::datos(void) //constructor{ cout<<"Bienvenidos a :"; getch();} datos::datos(char *n)//constructor con parametros{ cout<<n<<endl; getch();} int main (){ datos f("Wellcome to ESIME"),g; //Declaramos los parámetros del constructor getch(); return 0;}Programa Ulll_8//sobre carga de operadores donde quita una letra#include<iostream>#include<conio2.h>#include<string.h> //para concatenar y copiar cadenas using namespace std;

class cadena{ public: cadena(char *n); void sumar_letras(char*); void quitar_letra(char); void ver_cadena(void); private:

char datos[256];};cadena::cadena(char*str) //constructor con parametros{ strcpy(datos, str);

}void cadena::sumar_letras(char *str){ strcat(datos, " "); strcat(datos,str);}void cadena::ver_cadena(void){ cout<<datos<<endl;}void cadena::quitar_letra(char letra){ char temp[256]; int i,j; for(i=0, j=0; datos[i];i++) {

if(datos[i]!=letra) temp[j++]=datos[i]; }

temp[j]='\0'; strcpy(datos,temp); getch();

}int main(){ cadena titulo ("C++ al rescate");//parámetros del constructor titulo.ver_cadena(); titulo.sumar_letras("Otra cadena"); titulo.ver_cadena(); cadena lession("Que es la sobre carga de operadores"); lession.ver_cadena(); lession.quitar_letra('r');

lession.ver_cadena(); getch(); return 0; }

Sobrecarga de operadoresSon funciones miembro de la clase pero todas con el nombre de operator mas un operador.

Ejemplo:

void operator + (char *);

Para declarar:

Titulo de función “ “ signo de operación (+/-) tipo de función (char,int,float);

Programa Ulll_9//Ulll_9 operadores#include<iostream>#include<conio.h>#include<string.h>using namespace std;class cadena{ public: cadena(char *); char * operator +(char*); //solo se pone el signo de la operacion char * operator -(char); //solo se pone el signo de la operacion void ver_cadena(void); private: char datos[256];};cadena::cadena(char*str)//constructor con parametros{ strcpy(datos,str);}char * cadena::operator +(char *str){ strcat(datos," "); strcat(datos,str); return (datos); }void cadena::ver_cadena(void){ cout<<datos<<endl;}char * cadena::operator - (char letra){ char temp[256]; int i,j; for(i=0,j=0; datos[i]; i++) { if(datos[i]!=letra) temp[j++]=datos[i]; } temp[j]='\0'; strcpy(datos,temp); return (datos); // getch();} int main ()

{ cadena titulo("C++ al rescate"); titulo.ver_cadena(); titulo= titulo + "Otra cadena";//igualacion de un objeto con otro objeto titulo.ver_cadena(); cadena lesson("Que es la sobrecarga de operadores"); getch(); lesson.ver_cadena(); lesson=lesson - 'r';//igualacion de un objeto con otro objeto lesson.ver_cadena(); //clrscr(); getch(); return 0;}

Programa Ulll_10#include<iostream>#include<conio.h>#include<string.h>using namespace std;class cadena{ public: cadena(char *); char * operator +(char*); char * operator -(char); int operator ==(cadena); void ver_cadena(void); private: char datos[256];};cadena::cadena(char*str){ strcpy(datos,str);}char * cadena::operator +(char *str){ strcat(datos," "); strcat(datos,str); return (datos); }void cadena::ver_cadena(void){ cout<<datos<<endl;}char * cadena::operator - (char letra){

char temp[256]; int i,j; for(i=0,j=0; datos[i]; i++) { if(datos[i]!=letra) temp[j++]=datos[i]; } temp[j]='\0'; strcpy(datos,temp); return (datos); // getch();}

int cadena::operator==(cadena cad){ int i; // se compara la cadena letra por letra for(i=0; datos [i]==cad.datos[i]; i++) if((datos[i]==NULL)&&(cad.datos[i]==NULL)) return (1); return 0;} int main (){ cadena titulo("C++ al rescate"); cadena lesson("Que es la sobrecarga de operadores"); cadena cade("C++ al rescate"); titulo.ver_cadena(); titulo= titulo + "Otra cadena";//igualacion de un objeto con otro objeto titulo.ver_cadena(); //getch(); lesson.ver_cadena(); lesson=lesson - 'r';//igualacion de un objeto con otro objeto lesson.ver_cadena(); //clrscr(); if(titulo==cade) cout<<"son iguales"<<endl; else cout<<"No son iguales"<<endl; getch(); return 0;}

Herencia simpleDada una clase, se puede reusar en otra.

Class datos{char [50], dir[80], tel [30];public:

void introduce (void);void mostrar (void);

};Ejemplo agregando otra clase

class alumnos{char Gpo [ 20 ], bol[ 30 ];public:

void intro alum (void );void mostrar alum (void);

};Para utilizar la herencia en la segunda clase, se hace lo siguiente:class alumnos : datos {char Gpo [20], bol [30];public:void introalum (void);void mostraralum (void);alumnos ( char *,char *, char *,char *, char * )}; name dir tel se pasan los datos de la clase base

alumnos :: alumnos (char*name,char*dir,char *tel,char*Gpo,char*bol) : datos ffffffffffffffffffffffffffff(name,dir,tel)

{strcpy (name, alumnos :: name );strcpy (dir , alumnos :: dir );...}

Programa Ulll_11#include<iostream>#include<conio2.h>#include<string.h>

Clase Base.

la herencia se da atravez del constructor

using namespace std;class empleados //clase base(Primera Clase){ public: empleados(char*,char*,float); void ver_empleado(void); private: char nombre[50],puesto[80]; float salario;}; //Constructor Primera Claseempleados::empleados(char*nombre,char*puesto,float salario) { strcpy(empleados::nombre,nombre); strcpy(empleados::puesto,puesto); empleados::salario=salario;}void empleados::ver_empleado(void){ cout<<"Nombre:"<<nombre<<endl; cout<<"Puesto:"<<puesto<<endl; cout<<"Salario:"<<salario<<endl;} //Segunda clase(Ya con Herencia)class gerentes:empleados{ public: gerentes(char*,char*,char*,float,float,int); void ver_gerente(void); private: float bono; char auto_empresa[64]; int acciones;};//constructor con herencias <<<<------gerentes::gerentes(char*nombre,char*puesto,char*auto_empresa,float salario,float bono,int acciones):empleados(nombre,puesto,salario){ strcpy(gerentes::auto_empresa,auto_empresa); gerentes::bono=bono; gerentes::acciones=acciones;}void gerentes::ver_gerente(void){ ver_empleado(); //Funcion de la Primera Clase(Clase Base) cout<<"Auto:"<<auto_empresa<<endl; cout<<"Bono:"<<bono<<endl; cout<<"Acciones:"<<acciones<<endl;

}int main(){ empleados trabajador("Waldo","Oficinista",4500); gerentes jefe("Andres","Ingeniero","Audi",15000,10000,2); trabajador.ver_empleado(); jefe.ver_gerente(); getch(); return 0;}

Herencia MúltipleDada más de una clase (base) reusar en otras.Programa Ulll_12#include<iostream>#include<conio2.h>#include<string.h>using namespace std; class monitor //clase base 1{ public: monitor(char*,long,int,int); void ver_monitor(void); private: char tipo[50]; long colores; int resolucionx, resoluciony;};monitor::monitor(char* tipo,long colores,int resx,int resy){ strcpy(monitor::tipo,tipo); monitor::colores=colores; monitor::resolucionx=resx; resoluciony=resy;}void monitor::ver_monitor(void){ cout<<"Tipo:"<<tipo<<endl; cout<<"Colores:"<<colores<<endl; cout<<"Resolucion:"<<resolucionx<<"por" <<resoluciony<<endl;} class tarjeta//clase base 2{

public: tarjeta(int,int,int); void ver_tarjeta(void); private: int procesador; int velocidad; int ram;};tarjeta::tarjeta(int procesador,int velocidad,int ram){ tarjeta::procesador,procesador; tarjeta::velocidad,velocidad; tarjeta::ram,ram;}void tarjeta::ver_tarjeta(void){ cout<<"Procesador:"<<procesador<<endl; cout<<"Velocidad:"<<velocidad<<endl; cout<<"Ram:"<<ram<<endl;} //Tercera Clase- "Clase Heredada"class computadora:monitor,tarjeta //se le incluyen las dos anteriores clases(con"::", seguido de //la primera clase creada y con una coma para la segunda clase creada{ public: computadora(char*,int,char*,char*,long,int,int,int,int,int); void ver_computadora(void); private: char nombre[100]; int discoduro; char accesorios;};//constructor de Tercera Clase(Herencia)computadora::computadora(char*nombre,int discoduro,char*accsesorios,char*tipo,long colores,int resx,int resy,int procesador,int velocidad,int ram):monitor(tipo,colores,resolucionx,resoluciony),tarjeta(discoduro,velocidad,ram){ strcpy(computadora::nombre,nombre); computadora::discoduro=discoduro; strcpy(computadora::accesorios,accesorios);}void computadora::ver_computadora(void){ cout<<"Nombre:"<<nombre<<endl; cout<<"Discoduro:"<<discoduro<<endl; cout<<"Accesorios:"<<accesorios<<endl;}int main()

{ //monitor mon(); //tarjeta tar(); computadora pc("DELL",2,"DUD","HD","16000000",1200,950,2,3,8); pc.ver_computadora(); getch(); return 0;}

Templates/PlantillasUna plantilla es una función tipo molde genérica donde los datos pueden ser de diferente tipo.

Programa Ulll_13#include<conio2.h>#include<iostream>using namespace std;template<class E> //siempre va antes de la funcionE compara(E a,E b)//se le pone el Template antes de la funcion{ if(a>b) return(a); else return(b);}int main(){ int a,b,h; float x,y,z; cout<<"Dame el valor de a: "; cin>>a; cout<<"Dame el valor de b: "; cin>>b; cout<<"El mayor de: "<<a<<" y "<<b<<" es: " <<compara(a,b)<<endl; cout<<"Dame el valor de x: "; //copiamos lo de arriba y lo pegamos abajo cin>>x; //para volver a reutilzar la funcion ""COMPARA"(con el template) cout<<"Dame el valor de y: "; cin>>y; cout<<"El mayor de: "<<x<<" y "<<y<<" es: "//solo cambiamos los valore <<compara(x,y)<<endl; getch(); return 0;}

Programa Ulll_14

//Templates/plantillas#include<conio2.h>#include<iostream>#include<stdlib.h>using namespace std;template<class i,class f> //antes de la funcion se coloca el templatevoid ver_arreglo(f* array, i cuenta){ int indice; for(indice=0;indice <cuenta; indice++) cout<<array[indice]<<","; cout<<endl;}int main(void){ int pag[]={100,200,300,400,500};//se pasan directamente los datos de pag float precios[]={10.5,20.1,30.15};//se pasan directamente los datos de precios ver_arreglo(pag,5); ver_arreglo(precios,3); getch(); return 0;}

Programa Ulll_15//templates con clases//Ull1_15#include<conio2.h>#include<iostream>#include<stdlib.h>using namespace std;template<class s>//antes de la claseclass suma{ int x,y; public: suma(s ,s);};template<class s>suma <s>::suma(s x,s y) //constructor ---> Se le agrega el template{ cout<<x<<"+"<<y<<"="<<x + y<<endl;}int main(){ suma<int>n(5,3); //primero se pone el tipo de template, luego sigue el contenido del constructor suma<float>nf(28,63);//primero se pone el tipo de template, luego sigue el contenido del constructor

getch(); //system("pause"); return 0;}

Programa Ulll_16_1// Valor promedio#include<iostream>#include<conio2.h>#include<stdlib.h>using namespace std;

template<class T, class T1>//se declaran los templates(plantillas)class arreglo{ private: T *datos; int longitud, indice; public: arreglo(int); T1 suma(void);//se antepone el template T valor_promedio(void); //se antepone el template void muestra_arreglo(void); int Intro_valor(T);};

template<class T, class T1>// se pone antes de cada una de las funcionesarreglo<T,T1>::arreglo(int longitud){ datos=new T[longitud]; if(datos==NULL) { cerr<<"Memoria insuficiente"; exit(1); } arreglo::longitud=longitud; arreglo::indice=0;}

template<class T, class T1>T1 arreglo<T,T1>::suma(void){ T1 suma=0; for (int i=0; i<indice; i++) suma+=datos[i]; return(suma);}

template<class T, class T1>T arreglo<T,T1>::valor_promedio(void){ T1 suma=0; for(int i=0; i<indice; i++) suma+=datos[i]; return(suma/indice);}

template<class T, class T1>void arreglo<T,T1>::muestra_arreglo(void){ for(int i=0; i<indice; i++)cout<<datos[i]<< " " <<endl;}

template<class T, class T1>int arreglo<T,T1>::Intro_valor(T valor){ if(indice==longitud) return(-1); else { datos[indice]=valor; indice++; return (0); }}

int main(){ int i; system("cls"); arreglo<int,long>numero(100); for(i=0;i<50; i++) numero.Intro_valor(i); numero.muestra_arreglo(); cout<<"La suma del arreglo numero es: "<<numero.suma()<<endl; cout<<"\n El promedio es: "<<numero.valor_promedio()<<endl; arreglo<float,float>valores(200); for(i=0;i<100; i++) valores.Intro_valor(i*100); valores.muestra_arreglo(); cout<<"La suma del arreglo numero es: "<<valores.suma()<<endl; cout<<"\n El promedio es: "<<valores.valor_promedio()<<endl; getch(); return 0;}