INSTITUTO POLITCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERA MECNICA 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 punteros
Son variables que almacenan direcciones de memoria, su tamao es de 4 bytes
siempre en cualquier sistema operativo
1
byte

Su declaracin se da por:

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

char

pueden ser direcciones de memoria de otras variables.

char c; c

int x; x

Directriz, proporciona la
direccin de la variable

A
[F000
]

[F001..F00
2]
double w w
[F003..F00
A]

apc=&c;

char c;
char
apc;

apc

[F000
]

[F00B
]

1. cout<< apc; //F000 direccin donde apunta

2. cout<< &apc; //F00B direccin de apc
3. cout<< apc; // A valor de donde apunta

S.O,
programas
recidentes

Programas
ejecutables

Programa Ulll_1

Variables
estticas

Variables
Dinmicas

Total de la
RAM

#include<iostream>
#include<conio2.h>
using namespace std;
int main()
{
char c,*apc;
// se declara char el apuntador apc
int x,*apx;
// se declara entero el valor de apx
clrscr();
apc=&c;
// proporciona la direccin de la variable
*apc=x;
//para cambiar el valor de c desde apc
apx=&x;
//se le asigna el valor de x a apc
x=20;
// para cambiar el valor de x
cout<<El valor de c= <<*apc<<endl; //imprime el contenido de apc
cout<<El valor de x= <<*apx<<endl; //imprime el valor de apx
getch();
return 0;
}
Paso por Direccin
Manda la direccin y recibe direccin.
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 apuntador
Int x,y, *ap;// *ap declara el apuntador

[F000
]

[FB00
]
[FC00
]

//direcciones

[FB00
]
ap=&x; //pide la direccin de la variable x
ap=&y; // pide la direccin de la variable y
*ap= //pide el contenido de donde apunta
Nota: un apuntador no puede apuntar a dos variables a la vez.

Dos variables y dos apuntadores

Int x,y *ap, *ap2;
x

20

[FA00
]

20
[FC00
] 20

ap

ap

[FD0
[FB00
0]
]
Dos apuntadores
pueden apuntar a una misma direccin.
ap=&x;
ap2=&y;
ap=&y;
Programa Ulll_1_3
#include<iostream>
#include<conio2.h>
using namespace std;
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 datos

char name [20];
char *pname;
name
[ F000
]
cin>>name; //entrada por el usuario
A

pname
para que apunte una caja a la vez se debe declarar: pname= &name[ 0 ];
Arquitectura de apuntadores
pname=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 tool
using 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 memoria

existen 2 metodos para la asignacion de memoria dinamica

en C
en C++
C

C++

pedir

malloc

new

devolv
er

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 dinmicas 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 Estructuras
Apuntadores a Structs
struct fecha
{
int d,m,a;
} f , * pf;
// se declara el apuntador despus del nombre
Pf = &f; //pf esta apuntando a la caja f
Pf -> d //para cambiar el contenido de la caja d
Pf -> m // para cambiar el contenido de la caja m
Pf -> 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 usuario

Es ms de una funcin que se llama igual(el mismo nombre ms de una vez).
Como requisito debe haber una diferencia en los parmetros (diferentes tipos)
en el tipo de la funcin.
Programa Ulll_7
#include<iostream>
#include<conio2.h>
using namespace std;
class datos
{
public:
datos(); //Funcin 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 parmetros 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");//parmetros 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 operadores
Son funciones miembro de la clase pero todas con el nombre de operator
mas un operador.
Ejemplo:
void operator + (char *);
Para declarar:
Titulo de funcin

signo de operacin (+/-) tipo de funcin (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 simple
Dada una clase, se puede reusar en otra.
Class datos
{
Clase Base.
char [50], dir[80], tel [30];
public:
la herencia se da atravez
del constructor
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
base

se pasan los datos de la clase

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>
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 Clase
empleados::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 Mltiple
Dada ms 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,r
am)
{
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/Plantillas
Una plantilla es una funcin tipo molde genrica 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 funcion
E 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 template
void 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 clase
class 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 funciones
arreglo<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;