You are on page 1of 26

25

Instituto Politécnico Nacional
Escuela Superior de Ingeniería
Mecánica y Eléctrica
unidad Zacatenco

Apuntes de programación orientada a objetos

Profesora: America
Grupo: 2CM3

Alumno:
Hernández Nicolás José Eduardo

25

Contenido
Arreglos de caracteres...................................................................................... 14
Arreglos de números......................................................................................... 16
Bibliografía............................................................................................................ 3
Cadenas de caracteres...................................................................................... 14
Definición de funciones..................................................................................... 11
Estructura de los programas en C/C++......................................................................4
Estructuras anidadas........................................................................................ 17
Funciones de usuario........................................................................................ 10
Regresar valor................................................................................................... 11
Temario................................................................................................................ 3
Tipos Estructurados: struct............................................................................... 16
UR1.cpp............................................................................................................... 4
UR11................................................................................................................. 16
UR2.cpp.............................................................................................................. 9
UR3.cpp.............................................................................................................. 9
UR4 // programa Pacman.................................................................................. 12
UR5................................................................................................................... 13

Bibliografía 1. Ceballos. Fundamentos de programación orientada a objetos. Fco. 2. 5. Plantillas. Alfaomega. Aplicaciones. Enciclopedia del lenguaje C++. 4.Programación orientada a objetos TEMARIO 1. Herencia y polimorfismo. . 2da. Ed. Ed. C/C++. Ceballos. Alfaomega. curso de programación. J. J. Fco. 2da. 2. Clases y función miembro. 3.

Alfaomega. Ed. Programación orientada a objetos. 6. Savitch. J. 2da Ed. Programación orientada a objetos. REPASO Estructura de los programas en C/C++      Librerías. Ceballos. Declaración de variables globales. Ceballos. 7. J. Fco. Alfaomega. Enciclopedia de Visual C++. Alfaomega.cpp . Visual C++.NET. Definición o declaración de funciones de usuario. J. Resolución de problemas con C++ 2da. Definición de constantes o macros. 2da. 5. Mac Graw Hill. Ed. Aprenda y practique C++. Pretice Hall. Pappas y Murray. Jamsa. Ed. Fco. Oxford. 3da. Ceballos.3. 2da. 8. 4. Fco. Función principal void main ( ) { } UR1. Ed.

En turbo C void main (void) { } O int main (void) { return 0. } .h” Int main ( ) { printf(“Texto en pantalla”). cout<<”Texto en pantalla con cout”. } UR1_1.cpp #include <iostream. return 0.//Instrucción básica obligatoria para todos los programas en C++. } En Dev C++ y En Visual C++ int main ( ) { return 0. se tiene que agregar un return. void main ( ) { } La estructura/sintaxis de las funciones es: tipo de dato void nombre de la función main (lista de parametros) () Cuando la función no es void.h> #include “stdio.

UR1_2.h> #include <stdio. } #include <iostream. return 0. . return 0. T.Declaración de variables globales. return 0.PI). } MACRO: Es un pedazo de código que es sustituido por una variable.141592 //macro int main (void) { printf(“PI=%f”.PI).cpp #include <iostream.Definición de macros.PI). . Return 0.h> #include <stdio.h> #define PI 3.141592 int main ( ) { cout<<Pi=”<<PI. -Definición/declaración de usuario Declaración de la función definida.Librerías .141592 #define p printf int main ( ) { p(“PI=%f”.Función principal Int main ( ) { #define T printf(“Presione una tecla para finalizar”). } . #define PI 3. } Estructura básica .getch() int main ( ) { P(“PI=%f”.h> const double PI=3.

Ciclos – for. circle(100. Sirve para repetir/iterar una o más instrucciones. } “Intrucciones del lenguaje C++” if. Sirve para evaluar una respuesta. closegraph().100. Sintaxis If anidados if( preguntas) -instrucciones del SI If (pregunta) -SI else if(pregunta) if(pregunta) -SI else –NO else -NO else -instrucciones del NO Se puede omitir el if pero no el else . switch. setcolor(Rojo). do while.”Programa colores”). } UR1_4 #include <iostream> #include<graphics> using namespace std. return 0.600.Return 0. while. #define Azul BLUE #define Rojo RED Int main ( ) { initwindow(800. donde esa respuesta puede ser un número o un caracter. getch(). Sirve para realizar preguntas de manera que la respuesta sea un SI o un NO.30).

switch(car) { case ‘A’: cout<<”Hola grupo 2CM3”. i ++. cout<<”Programa terminado…”. Instrucciones break. case ‘S’: break. } Ciclos for(condición inicial. } . <. condición final. i == 10. cout<<endl.if( ) -SI Ejemplo: if (10 > 11) cout<<”11 es el mayor”.//break por falta de respuesta que abra el SI else cout<<”10 no es el mayos”. default: cout<<”Opción no valida”. i ++) { cout<<i. While (condición final) -instrucciones -incremento o decremento Ejemplo: i =1.\n } Nota: Para más de una instrucción se debe usar llaves {} Condición inicial. incremento o decremento) Ejemplo: for( i =1. while(i == 10) { cout<<i<<endl.

i ++. initwindow(640. do{ cout<<i <<endl. closegraph(). x=10.x<=600.cpp #include <iostream> #include <stdio.x++) { putpixel(x. y=10. UR3.y. pero adentro vuelve a tener condición inicial el mismo valor. Instrucciones Incremento o decremento }while(condición final) Ejemplo: i =1."Dibuja puntos"). }while(i == 10). int y.480.h> #include <graphics.do while condición inicial do{ //Puede estar donde sea la condicion inicial. depende del programa.cpp for(x=10. } system("pause"). UR2.RED).h> int main () { int x. return 0. } .

cout<<"*".y--"*"). case 77: clrscr(). gotoxy(x++.//outtextx. do{ getch (). case 27: break: } } while (f!=27). f=getch().y).O 32 bits 1 byte 2 bytes 4 bytes 8 bytes 2 bytes 4 bytes 8 bytes 16 bytes 8 bits ≈ byte . gotoxy(x. case 75: clrscr(). //moveto(x.y). //outtext("*").y). gotoxy(x. cout<<"*".9. int main () //auttextxy(x. char f. break: switch (f) clrscr().O 16 bits S. binario 1 S.600. cout<<"*".#include <iostrean> #include <conio2.y++). gotoxy(x--.y=24. { case 72: clrscr(). //clearderice(). break.h case 80: clrscr().y). return 0. cout<<"*". using namespace std. //initwindow(800. break.y--). cout<<"*". } Funciones de usuario Sintaxis: Tipo de dato Nombre de la función (lista de parámetros o argumentos) “Tipos de datos” Los tipos de datos en C++ Primitivos Tipo: Char Int Float double { 1 bit 0 sist . gotoxy (x.h> // graphies."Program"). break.11*) { int x=40.

y=9.y. Ejemplo: int suma (void) { int x. cout<<”La suma es: ”<<z. z=x+y. x=10.z.{ { { 0 sistema octal 0 sistema decimal 0 sistemahexadecimal −¿ 9 −¿ 9 −¿ F S. } Regresar valor Siempre que una función sea distinta de void debe regresar con “return” el mismo tipo de dato de la función. void } suma (void) { int suma (void) int main (void) .z. cout<<”La suma es: ”<<z.y. y=20. x=10. 64 bits 215 214 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 22 21 20 int 2 bytes float 4 bytes 231 230 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 22 21 20 double 8 bytes 263 262 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 22 21 20 Para excluir el tipo se usa void Ejemplo: int suma (void) void suma (void) { int x. Definición de funciones return (z).O. z=x+y.

int y). return (z).z. Fantasma().y. y=20. x=10. { int R. } UR4 // programa Pacman #include <iostream> #include <graphics. Pacman_Izq (int x. int main () { { char f.600. R=suma(). Pacman_Arr (int x. } int suma(void) { int x. } int main ()."Pacman"). y=20. z=x+y. switch(f) case Esc: break. Pacman_Aba (int x. { suma(). Fantasma().int y). Pacman_Der(x. int y=400.int y).h> #define Esc 27 #define Arriba 72 #define Abajo 80 #define Der 77 #define Izq 75 void void void void void Pacman_Der (int x. z=x+y. do { getch(). Fantasma (). initwindow(800.y). } int main ().int y).z. int x=50. cout<<”La suma es: ”<<z. return 0. f=getch(). x=10.y. case Arriba: cleardevice(). return 0.int x. if(y >= 50) } .

} else { x=850.y). pieslice(x.RED). } void Pacman_Izq (int x. int y) { setcolor(YELLOW). } else } Pacman_Arr(x. Fantasma(). setfillstyle (1. system("pause").35).210.BLACK). return 0. void Pacman_Arr (int x.y.120. //BOCA setfillstyle (1. break.{ }while (f!=Esc). Pacman_Arr(x. case Der: cleardevice(). pieslice(x.40).40).y-=5). pieslice(x.45. } void Fantasma () { int x=500. setfillstyle (1. .YELLOW).YELLOW). case Izq: cleardevice().315. if(x <= 850) { Pacman_Der(x+=5.y. } break.150. } else Pacman_Aba void Pacman_Der (int x. int y=400. int y) { setcolor(YELLOW). if(x >= -20) { Pacman_Izq(x=5.YELLOW).y).240. case Abajo: cleardevice().315.y. } (x. int y) { setcolor(YELLOW).0.y). setcolor(BLACK). pieslice(x.40). pieslice(x. Pacman_Izq (x.y).360.y). setfillstyle (1. Pacman_Der(x+=5. int y) { setcolor(YELLOW). closegraph().y.40).y.60. } else { x=0. break. setfillstyle (1.y+=5). } void Pacman_Aba (int x.y). if(y <= 550) { Pacman_Aba (x. setcolor(RED). setfillstyle (1.YELLOW). Fantasma(). Fantasma().

0.360. pieslice(490. srand(time(NULL)). } UR5 #include<iostream> #include<conio2. gotoxy(x.0.0.n++) { if(n>15) n=1.360.h> #include<cstdlib> #include<stdlib.395. pieslice(x+3. //OJO IZQ setfillstyle(1.BLACK). pieslice(490. pieslice(x+3. setfillstyle (1. y=rand()%25.RED).h> else { textcolor(n). setfillstyle(1. setcolor (WHITE).360. setcolor (BLACK). clrscr(). //OJO DER setfillstyle(1.5).5). setcolor (WHITE).12). } } return 0.360.!kbhit(). cout<<"*".12).360. x=rand()%80.0.n. for(n=1.y).y.395. setcolor (BLACK).y.WHITE). pieslice(520.27). pieslice(520. Sleep(10). } .0.395. setfillstyle(1.25). int main () { int x.y-5.395.0.} break. using namespace std. setcolor(RED).h> #include<windows.BLACK).WHITE).360.

o cin>>name[4]. getch(). cout<<"Nombre: "<<name[0]<<name[1]<<name[2]. } . name[2]='A'. //i=0 char name [10]. return 0. ‘\a’ Pitido ‘\b’ barra de retroceso UR6 #include <iostream> #include <conio2. /* */ name[0]='A'. int main () { //int i.Arreglos de caracteres char name [10] 0 8 name 1 9 2 3 4 5 6 7 ‘\n’ Salto de línea ‘\r’ Enter name [4]=getch(). system("cls"). name[1]='N'.H> using namespace std.

H> using namespace std. cout<<"\n\n\t Escribe un nombre:". do { name[i]=getche(). i=0. char papel[10].h> using namespace std. cout<<"\n\n\tEl nombre es: ". cin>>papel. system("cls"). cout<<"\n\tApellido Paterno: ". }while (name [i++]!='\r'). }while (name [i++]!='\r'). getch(). cout<<"\n\tNombre: ". } UR7 #include <iostream> #include <conio2. clrscr(). cin>>name. return 0. do { cout<<name[i]. char sapel[10]. int main () { int i. . char name [10]. int main () { char name[10].UR6_1 #include <iostream> #include <conio2. i=0. char nombre[50].

getch ().name). name[0]=’A’ name[1]=’N’ name[2]=’A’ name[3]=’\0’ ‘ A ’ ‘ N ’ ‘ A ’ ‘\ 0’ Programa en clase para 2 puntos . C gets(name). cin.ignore(). al final debe existir un carácter especial llamado nolo (NULL) ‘\0’. } Cadenas de caracteres La diferencia de arreglo y cadena es el NULL Son un conjunto de caracteres de manera secuencial. cout<<"\n\tDame otro nombre: ".50).get(name.get(nombre. cin. cin>>sapel. scanf(“%s”. C++ cin>> name. //con espacios.10). cout<<"\n\tEl primer nombre es: "<<name<<" "<<papel<<" "<<sapel<<endl. cout<<"\n\tEl segundo nombre es: "<<nombre.cout<<"\n\tApellido Materno: ". return 0. // sin espacios en blanco. cin.

char pass[10].get(usu. gotoxy(15. char usu[10]. return 0.10). int main () { int i=0. cout<<”\nusu’”<<usu<<”pass\n\n”<<endl. /*while(pass[i]=getch() !='\r') i++. Int main (). cout<<"\n\n\t\tPassword: ". i++) cout<<pass[i].i++) cin>>pass[i].i<10. { int i=0. .get(usu. for(i=0. char usu[10]. cout<<"\n\tUsuario: "<<usu<<"\n\n\tPassword: ". cin.*/ for(i=0.20). } UR8 #include <iostream> #include <conio2. for(i=0. cin.10). cout<<"\n\n\tUsuario: ". char pass[10].#include <iostream> #include <conio2. cout<<”\n\n\tpassword: ” while((pass[i]=getch())!= ‘\r’) i++.i++) cout<<pass[i].h> using namespace std.h> using namespace std.i<10. cout<<”usuario”. i<10.

int i. // x+=10.y). int x=300. int main( ) { initwindow( 640 . "WinBGIm" ).getch(). return( 0 ).150). getch().RED).450.h> using namespace std. }while (name [i++]!='\r'). name[i]=getch(). } UR9 #include <iostream> #include <graphics. 480 . bar(300. do { setcolor(BLUE). char name [10]. setfillstyle(1. cout<<"\n\n\t Escribe un nombre:". i=0.100. closegraph( ). name[i+1]='\0'. return 0. } UR10 Arreglos de números . int y=100. moveto(x. outtext(name).

get(l). cin. float suma=0. j++) { cout<<"\nDame calificacion "<<i+1<<": ". clrscr(). cout<<"Cuantos nomeres quieres? ". cin>>calif[i][j]. } calif[i][j]=suma/3. i++) { cout<<"Dame el nombre "<<i+1<<": ".h> #define f 4 using namespace std. 4 bytes por celda Double [3]. Int vect[10]. i<n.Puede ser float. double y nombre que sea. int main () { float calif [30][4]. cout<<"\n". suma=suma+calif[i][j]. for(i=0. int i. cin. 8 bytes por celda UR11 #include <iostream> #include <conio2. cout<<"\nLos datos proporcionados son:". } clrscr(). char l. i<n. } UNIDAD I Tipos Estructurados: struct .50). i++) { cout<<"\n\nNombre: "<<names[i]<<endl.get(names[i]. } for(i=0. } getch(). cin. 2 bytes por celda Float w[5] .j.n. cout<<"\nCalificacion final: "<<calif[i][j].get(l). j<3. return 0. i++) { suma=0. for(j=0. i<n. j=3. cin>>n. for(i=0. char names [30][50].

} Estructuras anidadas Una estructura anidada es una estructura o más dentro de otra sintaxis: Struct una Struct dos Struct dos .m <<"/"<<h. cin>>h. }h.50).m<<"/"<<f. cout<<"Hoy es:"<<h.a. int a.h> using namespace std. cin>>h.m. cout<<"otra fecha es: "<<f. cin>>nomvar.d<<"/" <<f. cout<<”\n mes: ”.d. cin>>f. cout<<”\nAnhos: ”.m. clrscr(). cinget(nomvar. return 0. UI1 #include <iostream> #include <conio2. nombar.d.d=10. char m[20].m. cout<<”\nDame la fecha de hoy: ”. cout<<”\nAnho: ”.a. struct flecha { int d.a=2013. getch().a. cin>>h. }nomvar.names [0]. cin>>f.Sintaxis: Struct nomstruct { int d.a<<endl. cout<<”Dame una fecha: ”.a<<endl. char m[10]. cout<<”Dia: ”. Estructura es un conjunto (más de 1) de datos de diferente o igual tipo nombar. int main() { fecha f. cin>>f. cout<<”\nDia: ”.d<<"/"<<h. cout<<”\n mes: ”. clrscr().

switch(rc) { case '1': clrscr(). ". char name[50]. UI2 #include<iostream> #include<conio2.dir[80]. }h. Una dentro. void introduce (void). }dentro. struct una { int x. { char l. int edad. }agenda. void eliminar (void). { char name[50].name. struct datos { char name[50]. cin. break.get(agenda.h> #include<string. char email[80]. h. void cambio (void).{ { int x.Regresar". rc=getch(). } h.get(agenda. cout<<"Telefono: ".x. cin. }cajota. tel[30].dir.y. case '2': clrscr(): cout<<"Direccion: ". cout<<"Nombre: using namespace std. void introduce (void).y.50).80). case '3': clrscr().y. cout<<"nombre: ".h> cout<<"\n7. break. . //para quitar el enter cout<<"Itroduce los datos"<<endl.

case '5': clrscr().get(l). case '4': clrscr(). clrscr().get(l). cout<<"Email: ". cout<<"\n4. introduce().dir. if(cont!=0) { cout<<"Que cambio deseas?"<<endl.name.Direccion". cout<<"\n1. getch().get(agenda.cin. cout<<"\n3.Email". cout<<"\n6. break.edad. cout<<"\n4. case '7': break. cin. int r. cin.30). switch (r) { void borrar (void) { } . } int main () { char op. cin>>agenda. cout<<"*** Menu ***"<<endl. cin.edad.80). default: cout<<"opcion no valida".get(l). Cambios".get(agenda.80). cout<<"Telefono: ".Telefono".email.// op=getch().tel.Edad". } void cambios (void) { char rc. cout<<"\n2.80).50).email. cout<<"email: ". break. Introducir datos". cout<<"Edad: ". cout<<"\n1. break. } } else cout<<"no hay datos".get(agenda. cin.// para limpiar el buffer del teclado cin.30). cout<<"\n5.Todos".get(agenda. cout<<"Edad: ". cin>>agenda. Borrar ".get(agenda. cin. cout<<"\n2. cin>>r. cout<<"\n3. break. cin. case '6': clrscr().Nombre".get(agenda. cout<<"Direccion: ". Salir".tel. cin.

default: cout<<"Opcion no valida".case '1': clrscr(). } getch(). borrar(). case '4': break. break. case '3': clrscr(). cambios(). return 0. break. introduce(). . break. case '2': clrscr().

get (l).h> #include<string.get(docente.carrera[30].UI3 #include<iostream> #include<conio2.materia[30]. muestraProfe(). muestraAlum (void. struct prof { personales pers. char gpo[20]. cout<<”\n Promedio: ”. muestraAlum(). getch(). dir[80].ir. cin.pers. }alumno. introAlum().50).h> void void void void introProfe (void). char cat[30]. } struct alumno { personales al. cout<<”\nDireccion: ”. void introProfe (void) { char l. struct personales { char name[50].prom. int main () { clrscr(). char bol[30].salón[20]. cin. muestraProfe (void).get(docente. introAlum (void).80). cin>>alumno. cout<<”Nombre profesor: ”. }. float prom.pers. cout<<”\nLos datos del profesor .name. introProfe(). int edad. }docente. return 0. cin. float salario. tel[30]. } void muestaProf (void) { clrscr().) using namespace std.

carrera <<”\nGrupo: ”<<alumno.20).get(alumno. cin. cin.al.30). } . cin.al.prom.pers. cout<<”Nombre del alumno: ”.edad. 30). } void muestraAlum (void) { clrscr().salario. cin.salon. <<”\nNombre: ”<<docente. cout<<”\n salario: ”.80).pers. cout<<”\n Salon: ”. cout<<”\nNombre: ”<<alumno. cin.get(l).pers.30).al.get(docente.salon <<”\nPromedio: ”<<alumno.pers.materia <<”\nSalario: ”<<docemte.get(l).get(alumno.get(alumno. cout<<”\nCategoria: ”. cin.tel.gpo <<”\nSalon: ”<<alumno. cin.get(alumno. cin>>alumno.get(alumno.pers.get (l).dir <<”\nTelefono: ”<<docente.al. cin.30).tel. cout<<”\n Boleta: ”.dir. cin. son: ”. cin. cin.get(l).edad. cin.tel <<”\nEdad: ”<<alumno. cout<<”\n Carrera: ”.get(l).get(alumno.dir <<”\nTelefono: ”<<alomno.20). cin.get(l). cin>>docente. cin.cat. cout<<”\n Edad: ”.al.edad <<”\nCategoria: ”<<docente.get(l). cin.name.cout<<”\n Tel: ”. } void introAlum (void) { char l.edad <<”\nBoleta: ”<<alumno.get(docente. cin. cin.pers. cout<<”\n Telefono: ”. cout<<”\nDatos alumno: ”.bol.get(alumno. cin>>docente.tel <<”\nEdad: ”<<docente. 50).carrera.name <<”\nDireccion: ”<<alumno. cout<<”\nDireccion: ”.get(l).name <<”\nDireccion: ”<<docente. getch().gpo.cat <<”\nMateria: ”<<docente. cout<<”\n edad: ”.salario.bol <<”\nCarrear: ”<<alumno.al. cout<<”\nGrupo: ”.30).al.