Beruflich Dokumente
Kultur Dokumente
LABORATORIO DE COMPUTACION
APUNTES DE CLASE
GRUPO: 2CM2
ALUMNO:
AlCANTARA SANCHEZ ALDO YAIR
PROFESORA:
GONZALEZ SANCHEZ AMERICA
Su declaracin se da por:
char *apc;
int *apc;
float *apc;
double *apc;
char
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
]
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.
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.
}
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;
}
en C
en C++
C
C++
pedir
malloc
new
devolv
er
free
delete
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
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];
};
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
{
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;