Sei sulla pagina 1di 17

COLEGIO NACIONAL DE EDUCACION PROFESIONAL TECNICA

PLANTEL AGS. 1
J.REFUGIO ESPARZA REYES

NOMBRE: JORGE DAVID VILCHIS MANZANO


NOMBRE DEL PROFESOR(A): YOLANDA NAVARRETE
MODULO: PROGRAMACION ORIENTADA A OBJETOS
FECHA: 24-MARZO-2017
GRUPO: 410 SEMESTRE: IV
CICLO ESCOLAR 2016-2017
INDICE

Cdigo para hacer nmeros randomizados 3

Libreras bsicas de Dev-C++ 3

Librera <String.h> y funcione 3

Estructuras 13

Manejo de archivos directos 14

Manejo de archivos secuenciales 17

2
Nmeros randomizados

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

Int main()
{
int x,y;
srand (time(NULL));
x=rand()%9;
y=rand()%9;
printf(%d,x);
printf(%d,y);
getch();
}

LIBRERIAS BASICAS USADAS EN DEVC++

Fstream: Permite la munipulacion de archivos desde el programador, tanto leer como escribir en ellos.

Iosfud: Contienen declaraciones adelantadas de todas las plantillas de flujo y sus typedets estandar. por
ejemplo: Ostream

List: Parte de la STL relativa a los contenedores tipo list, lista doblemente enlazada.

Math: contiene los prototipos de las funciones, otras definiciones para el uso y manupulacion de funciones
matematicas.

Memory: utilidades relativas a la gestion de memoria incluyendo asignadores y punteros inteligentes.

New: Manejo de memoria dinamica

Numeric: Parte de la libreria numerica de la STL relativa a operaciones numericas.

Ostream:Algoritmos estandar para los flujos de salida

Queve: Parte de la STL relativa a contenedores tipoqueve (Colas de Objeto)

Studio: Contiene los prototipos de las funciones macros, para para utilidades de uso general.

String: Parte de la STL relativa a contenedores tipo string, una generalizacion de las cadenas alfanumericas
para albergar cadenas de objetos, pues eliminan muchas de las dificultades que generan las char.

Typcinto: Mecanismo de identificacion de tipo en tiempo de ejecucion.

Vector: Parted e la STL relativa a los contenedores tipo vector, una generacion de las matrices
unidimencionales.

3
#include <string.h>: Es para utilizar las funciones de manejo de cadenas
#include <string>: Es para utilizar cadenas

Funciones de la librera string

memchr
void *memchr(const void *s, int c, size_t n);

Localiza la primera aparicin del carcter c (convertido a unsigned char) en los primeros n caracteres (cada uno
interpretado como un unsigned char) del objeto apuntado por s.

#include <stdio.h>
#include <string.h>
int main()
{
char cadena[] = "Erase una vez...";
char *puntero;
puntero = (char *)memchr( cadena, 'a', 5 );
printf( "%s\n", cadena);
printf( "%s\n", puntero );
return 0;
}

memcmp
int memcmp(const void *s1, const void *s2, size_t n);

Compara los primeros n caracteres del objeto apuntado por s1 (interpretado como unsigned char) con los
primeros n caracteres del objeto apuntado por s2 (interpretado como unsigned char).

#include <stdio.h>
#include <string.h>
int main()
{
char a[3] = { 82, 81, 84 };
char b[3] = { 85, 83, 86 };
int i;
for( i=0; i<3; i++ )
printf( "a[%d]=%c ", i, a[i] );
printf( "\n" );
for( i=0; i<3; i++ )
printf( "b[%d]=%c ", i, b[i] );
printf( "\n" );
i = memcmp( a, b, 4 );
printf( "a es " );
if( i < 0 ) printf( "menor que" );
else if( i > 0 ) printf( "mayor que" );
else printf( "igual a" );
printf( " b\n" );
return 0;
}

memcpy
void *memcpy(void *s1, const void *s2, size_t n);

Copia los primeros n caracteres del objeto apuntado por s2 al objeto apuntado por s1.

#include <stdio.h>
#include <string.h>
4
int main()
{
char a[7] = "abcdefg";
char *ptr;
int i;

memcpy( ptr, a, 5 );
for( i=0; i<7; i++ )
printf( "a[%d]=%c ", i, a[i] );
printf( "\n" );
for( i=0; i<5; i++ )
printf( "ptr[%d]=%c ", i, ptr[i] );
printf( "\n" );

return 0;
}

memmpye
void *memmove(void *s1, const void *s2, size_t n);

Copia los primeros n caracteres del objeto apuntado por s2 al objeto apuntado por s1.Sin embargo, se asegura de que
no estn superpuestos. Por esta razn, copia los caracteres a un array/arreglo temporalmente. Despus vuelve a copiar
del array temporal al objeto en cuestin.

#include <stdio.h>
#include <string.h>

int main()
{
char a[7] = "abcdefg";
char *ptr;
int i;

memmove( ptr, a, 5 );
for( i=0; i<7; i++ )
printf( "a[%d]=%c ", i, a[i] );
printf( "\n" );
for( i=0; i<5; i++ )
printf( "ptr[%d]=%c ", i, ptr[i] );
printf( "\n" );

return 0;
}

memset
void *memset(void *s, int c, size_t n);

Copia el valor de c (convertido a unsigned char) en cada uno de los primeros n caracteres en el objeto apuntado por s.

#include <stdio.h>
#include <string.h>

int main()
{
char c = 'F';
char *s;
int i;
5
s = (char*)malloc(5*sizeof(char));
memset( s, c, 5 );
for( i=0; i<5; i++ )
printf( "c[%d]=%c ", i, c );
printf( "\n" );
free(s);
return 0;
}

strcst
char *strcat(char*s1, const char *s2);

Aade una copia de la cadena apuntada por s2 (incluyendo el carcter nulo) al final de la cadena apuntada por s1. El
carcter inicial de s2 sobrescribe el carcter nulo al final de s1.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[11] = "Hola ";
char s2[6] = "amigos";

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );
strcat( s1, s2 );
printf( "s1=%s\n", s1 );

return 0;
}

strchr
char *strchr(char *s, int c);

Localiza la primera aparicin de c (convertido a unsigned char) en la cadena apuntada por s(incluyendo el
carcter nulo).

#include <stdio.h>
#include <string.h>

int main()
{
char s[11] = "Hola amigos";
char c = 'a';

printf( "s=%s\t", s );
printf( "c=%c\n", c );
printf( "strchr=%s\n", strchr( s, c ) );

return 0;
}

strcmp

6
int strcmp(const char *s1, const char *s2);

Compara la cadena apuntada por s1 con la cadena apuntada por s2.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[5] = "Abeja";
char s2[5] = "abeja";
int i;

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );

i = strcmp( s1, s2 );
printf( "s1 es " );
if( i < 0 ) printf( "menor que" );
else if( i > 0 ) printf( "mayor que" );
else printf( "igual a" );
printf( " s2\n" );

return 0;
}

strcoll
int strcoll(const char *s1, const char *s2);

Compara la cadena apuntada por s1 con la cadena apuntada por s2, ambas interpretadas acordes a la
categora LC_COLLATE de la localidad actual.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[5] = "Abeja";
char s2[5] = "abeja";
int i;

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );

i = strcoll( s1, s2 );
printf( "s1 es " );
if( i < 0 ) printf( "menor que" );
else if( i > 0 ) printf( "mayor que" );
else printf( "igual a" );
printf( " s2\n" );

return 0;
}

strcpy
char *strcpy(char *s1, const char *s2);

Copia la cadena apuntada por s2 (incluyendo el carcter nulo) a la cadena apuntada por s1.

#include <stdio.h>
7
#include <string.h>

int main()
{
char s2[8] = "abcdefg";
char s1[8];

strcpy( s1, s2 );
printf( "s2=%s\n", s2 );
printf( "s1=%s\n", s1 );

return 0;
}

strcspn
size_t strcspn(const char *s1, const char *s2);

Cuenta el nmero de caracteres de una subcadena inicial apuntada por s1 que no contenga ninguno de los caracteres
en la cadena apuntada por s2.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[13] = "Hola a todos";
char s2[5] = "abcd";

printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strcspn(s1,s2) = %d\n", strcspn( s1, s2 ) );

return 0;
}

strerror
char *strerror(int errnum);

Convierte el nmero de error en errnum a un mensaje de error (una cadena de caracteres).

#include <stdio.h>
#include <string.h>

int main()
{
int errnum;

for( errnum=0; errnum<39; errnum++ )


printf( "strerror(%d) = %s\n", errnum, strerror( errnum ) );

return 0;
}

strlen
size_t strlen(const char *s);

Calcula el nmero de caracteres de la cadena apuntada por s.

8
#include <stdio.h>
#include <string.h>

int main()
{
char s[13] = "Hola a todos";

printf( "s=%s\n", s );
printf( "strlen(s) = %d\n", strlen( s ) );

return 0;
}

strncat
char *strncat(char*s1, const char *s2, size_t n);

Aade no ms de n caracteres (un carcter nulo y los dems caracteres siguientes no son aadidos) de la cadena
apuntada por s2 al final de la cadena apuntada por s1. El carcter inicial de s2 sobrescribe el carcter nulo al final
de s1. El carcter nulo siempre es aadido al resultado.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[11] = "Hola ";
char s2[6] = "amigos";

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );
strncat( s1, s2, 3 );
printf( "s1=%s\n", s1 );

return 0;
}

strncmp
int strncmp(const char *s1, const char *s2, size_t n);

Compara no ms de n caracteres (caracteres posteriores al carcter nulo no se tienen en cuenta) de la cadena


apuntada por s1 con la cadena apuntada por s2.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[9] = "artesano";
char s2[8] = "artista";
int i;

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );

i = strncmp( s1, s2, 3 );


printf( "Las 3 primeras letras de s1 son " );
if( i < 0 ) printf( "menores que" );
else if( i > 0 ) printf( "mayores que" );
else printf( "iguales a" );
printf( " s2\n" );
9
return 0;
}

strncpy
char *strncpy(char *s1, const char *s2, size_t n);

Copia no ms de n caracteres (caracteres posteriores al carcter nulo no son copiados) de la cadena apuntada por s2 a
la cadena apuntada por s1.

#include <stdio.h>
#include <string.h>

int main()
{
char s2[8] = "abcdefg";
char s1[8];
strncpy( s1, s2, 3 );
printf( "s2=%s\n", s2 );
printf( "s1=%s\n", s1 );
return 0;
}

strpbrk
char *strpbrk(const char *s1, const char *s2);

Localiza la primera aparicin de la cadena apuntada por s1 de cualquier carcter de la cadena apuntada por s2.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[13] = "Hola a todos";
char s2[5] = "deip";
printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strpbrk(s1,s2) = %s\n", strpbrk( s1, s2 ) );
return 0;
}

strrchr
char *strrchr(char *s, int c);

Localiza la ltima aparicin de c (convertido a unsigned char) en la cadena apuntada por s(incluyendo el
carcter nulo).

#include <stdio.h>
#include <string.h>

int main()
{
char s[11] = "Hola amigos";
char c = 'a';
printf( "s=%s\t", s );

10
printf( "c=%c\n", c );
printf( "strrchr=%s\n", strrchr( s, c ) );
return 0;
}

strspn
size_t strspn(const char *s1, const char *s2);

Calcula el nmero de caracteres de una subcadena inicial apuntada por s1 que consiste en todos los caracteres
formados en la cadena apuntada por s2.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[13] = "Hola a todos";
char s2[5] = "Hola";
printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strspn(s1,s2) = %d\n", strspn( s1, s2 ) );
return 0;
}

strstr
char *strstr(const char *s1, const char *s2);

Localiza la primera aparicin en la cadena apuntada por s1 de la secuencia de caracteres (excluyendo el carcter nulo)
en la cadena apuntada por s2.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[13] = "Hola a todos";
char s2[3] = "la";
printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strstr(s1,s2) = %s\n", strstr( s1, s2 ) );
return 0;
}

strtok
char *strtok(char *s1, const char *s2);

Rompe la cadena s1 en segmentos o tkens. Esta ruptura destruye s1, en el proceso. La forma de romper la cadena
depende de la secuencia de caracteres de la cadena s2. Estos caracteres se denominan [caracteres] delimitadores. La
funcin recorrer la cadena en busca de alguno de los delimitadores de la cadena s2. Cuando lo encuentre, el proceso
se detiene, ya que tiene un token. Posteriores llamadas a strtok rompern la cadena s1 en otros tkens. Estas llamadas
pueden tener otra secuencia de delimitadores.

#include <stdio.h>
#include <string.h>

int main()
{
char s1[49] = "Esto es un ejemplo para usar la funcion strtok()";
char s2[4] = " \n\t";

11
char *ptr;
printf( "s1=%s\n", s1 );
ptr = strtok( s1, s2 ); // Primera llamada => Primer token
printf( "%s\n", ptr );
while( (ptr = strtok( NULL, s2 )) != NULL ) // Posteriores llamadas
printf( "%s\n", ptr );
return 0;
}

strxfrm
size_t strxfrm(char *s1, const char *s2, size_t n);

Transforma la cadena apuntada por s2 y coloca la cadena resultante en el array/arreglo apuntado por s1. La
transformacin es tal que, si la funcin strcmp es aplicada a las dos cadenas transformadas, el valor de retorno
corresponder a los valores de retorno de la funcin strcoll. No ms de n caracteres son colocados en el array
resultante apuntado por s1, incluyendo el carcter nulo. Si n es cero, s1 puede ser un puntero nulo.

#include <stdio.h>
#include <string.h>
int main()
{
char s2[7] = "abcdefg";
char s1[7];
int i;
i = strxfrm( s1, s2, 4 );
printf( "s2=%s\n", s2 );
printf( "s1=%s\tlonguitud=%d\n", s1, i );
return 0;
}

12
STRUCTURAS

Las estructuras son llamadas tambin muy a menudo registros, o en ingls records. Tienen muchos
aspectos en comn con los registros usados en bases de datos. Y siguiendo la misma analoga, cada
objeto de una estructura se denomina a menudo campo, o field.
Sintaxis:

struct [<identificador>] {
[<tipo> <nombre_objeto>[,<nombre_objeto>,...]];
} [<objeto_estructura>[,<objeto_estructura>,...];

Una vez definida una estructura, es decir, si hemos especificado un nombre para ella, se puede usar igual
que cualquier otro tipo de C++. Esto significa que se pueden declarar ms objetos del tipo de estructura en
cualquier parte del programa. Para ello usaremos la forma normal de declaracin de objetos, es decir:

[struct] <identificador> <objeto_estructura>


[,<objeto_estructura>...];

En C++ la palabra struct es opcional en la declaracin de objetos, al contrario de lo que sucede en C, en el


que es obligatorio usarla.

Ejemplo:
struct Persona {
char Nombre[65];
char Direccion[65];
int AnyoNacimiento;
} Fulanito;

Este ejemplo define la estructura Persona y declara a Fulanito como un objeto de ese tipo. Para acceder al
nombre de Fulanito, por ejemplo para visualizarlo, usaremos la forma:

cout << Fulanito.Nombre;

13
Manejo de archivos directo

El archivo de cabecera fstream.h define las clases ifstream, ostream y fstream para operaciones de
lectura, escritura y lectura/escritura en archivos respectivamente. Para trabajar con archivos debemos
crear objetos de stas clases de acuerdo a las operaciones que deseamos efectuar. Empezamos con las
operaciones de escritura, para lo cual bsicamente declaramos un objeto de la clase ofstream, despus
utilizamos la funcin miembro open para abrir el archivo, escribimos en el archivo los datos que sean
necesarios utilizando el operador de insercin y por ltimo cerramos el archivo por medio de la funcin
miembro close, ste proceso est ilustrado en nuestro primer programa, archiv01.cpp.

//***********************************************
// archiv01.cpp
// Demuestra la escritura bsica en archivo
// 1999, Jaime Virgilio Gmez Negrete
//***********************************************

#include <fstream.h>

int main()
{
ofstream archivo; // objeto de la clase ofstream

archivo.open("datos.txt");

archivo << "Primera lnea de texto" << endl;


archivo << "Segunda lnea de texto" << endl;
archivo << "ltima lnea de texto" << endl;

archivo.close();
return 0;
}

Naturalmente, al utilizar la funcin constructora ya no es necesario utilizar la funcin miembro open, sta
forma de abrir un archivo es preferida porque el cdigo es ms compacto y fcil de leer. De la misma
forma que se utilizan manipuladores de salida para modificar la presentacin en pantalla de los datos del
programa, igual es posible utilizar stos manipuladores al escribir datos en un archivo como lo demuestra
el programa archiv02.cpp, observe que se utiliza un constructor para crear y abrir el archivo
llamado Datos.txt:
//***********************************************
// archiv02.cpp
// Demuestra el uso de manipuladores
// 1999, Jaime Virgilio Gmez Negrete
//***********************************************

#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>

int main()
{
ofstream archivo("Datos.txt"); // constructor de ofstream
int numero;

cout << "Introduzca un numero:" << endl;


cin >> numero;
archivo << "El valor introducido en base 10 es: " << numero << endl;

archivo << resetiosflags(ios::dec);

14
archivo << setiosflags(ios::oct);
archivo << "en base octal es: " << numero << endl;

archivo << resetiosflags(ios::oct);


archivo << setiosflags(ios::hex);
archivo << "y en base hexadecimal es: " << numero << endl;
archivo << setiosflags(ios::uppercase|ios::showbase);
archivo << "utilizando los manipuladores uppercase y showbase"
<< " el valor es: " << numero << endl;

archivo << resetiosflags(ios::uppercase|ios::showbase);


archivo << resetiosflags(ios::hex);
archivo << setiosflags(ios::showpos|ios::showpoint|ios::fixed);
archivo << "Utilizando los manipuladores showpos," << " showpoint y fixed: " << (float)numero << endl;

archivo << resetiosflags(ios::showpos|ios::showpoint|ios::fixed);


archivo << "Finalmente el valor es " << numero << endl;

archivo.close();

return 0;
}
Modos de apertura de archivo

Al especificar la apertura de un archivo como se ha mostrado en los programas anteriores, el programa


sobreescribe cualquier archivo existente llamado Datos.txt en el directorio de trabajo del programa.
Dependiendo del propsito del programa es posible que sea necesario agregar datos a los ya existentes
en el archivo, o quiz sea necesario que las operaciones del programa no se lleven a cabo en caso de que
el archivo especificado exista en el disco, para stos casos podemos especificar el modo de apertura del
archivo incluyendo un parmetro adicional en el constructor, cualquiera de los siguientes:

ios::app Operaciones de aadidura.


ios::ate Coloca el apuntador del archivo al final del mismo.
ios::in Operaciones de lectura. Esta es la opcin por defecto para objetos de la clase ifstream.
ios::out Operaciones de escritura. Esta es la opcin por defecto para objetos de la clase ofstream.
ios::nocreate Si el archivo no existe se suspende la operacin.
ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operacin se suspende.
ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.
ios::binary Operaciones binarias.

Operaciones de lectura de archivos

Para abrir un archivo y realizar operaciones de lectura se crea un objeto de la clase ifstream y se procede
prcticamente de la misma forma que lo expuesto en el apartado anterior. Despus de abrir el archivo se
puede leer su contenido utilizando las funciones miembro de la clase ifstream o bin el operador de
extraccin. Cuando se lee un archivo, por lo general se empieza al principio del mismo y se leer su
contenido hasta que se encuentre el final del archivo. Para determinar si se ha llegado al final del archivo
se puede utilizar la funcin miembro eof como condicin de un bucle while. Adems se puede utilizar la
funcin miembro fail para detectar un error al abrir el archivo, esto se demuestra en el siguiente
programa, archiv03.cpp:
//***********************************************
// archiv03.cpp
// Demuestra operaciones de lectura de archivos
// 1999, Jaime Virgilio Gmez Negrete
//***********************************************

#include <fstream.h>

15
int main()
{
ifstream archivo("Pruebas.txt", ios::noreplace);
char linea[128];
long contador = 0L;

if(archivo.fail())
cerr << "Error al abrir el archivo Pruebas.txt" << endl;
else
while(!archivo.eof())
{
archivo.getline(linea, sizeof(linea));
cout << linea << endl;
if((++contador % 24)==0)
{
cout << "CONTINUA...";
cin.get();
}
}
archivo.close();
return 0;
}

Analizando el xito de E/S de archivos

En el programa archiv03.cpp se utiliz la funcin miembro fail( ) para determinar el xito de la operacin
de apertura del archivo Pruebas.txt. La funcin miembro fail( ) produce el valor de 1 si ocurre un error en
la operacin de archivo. Similarmente es recomendable utilizar otras funciones para verificar no solo la
apertura de archivo sino tambin las operaciones de lectura y escritura, las funciones miembro que nos
permiten stas pruebas son las siguientes:

good Produce un 1 si la operacin previa fu exitosa.


eof Produce un 1 si se encuentra el final del archivo.
fail Produce un 1 si ocurre un error.
bad Produce un 1 si se realiza una operacin invlida

//*********************************************************
// archiv04.cpp
// Demuestra xito en operaciones de E/S de archivos
// 1999, Jaime Virgilio Gmez Negrete
//*********************************************************

#include <fstream.h>
#include <stdlib.h>

int main()
{
ifstream origen("Pruebas.txt");
char linea[128];

if(origen.fail())
cerr << "Error al abrir el archivo Pruebas.txt" << endl;
16
else
{
ofstream destino("Copia.txt", ios::noreplace);
if(destino.fail())
cerr << "Error al crear el archivo: Copia.txt" << endl;
else
{
while(!origen.eof())
{
origen.getline(linea, sizeof(linea));
if(origen.good()) // si lectura ok y
if(origen.eof()) // si eof, -> termina
exit(1); // el programa
else
destino << linea << endl;
if(destino.fail())
{
cerr << "Fallo de escritura en archivo" << endl;
exit(1);
}
}
}
destino.close();
}
origen.close();

return 0;
}

Manejo de archivos secuenciales


En estos archivos, la informacin slo puede leerse y escribirse empezando desde el principio del archivo.
Los archivos secuenciales tienen algunas caractersticas que hay que tener en cuenta:
1. La escritura de nuevos datos siempre se hace al final del archivo.
2. Para leer una zona concreta del archivo hay que avanzar siempre, si la zona est antes de la zona actual
de lectura, ser necesario "rebobinar" el archivo.
3. Los ficheros slo se pueden abrir para lectura o para escritura, nunca de los dos modos a la vez.
Esto es en teora, por supuesto, en realidad C no distingue si los archivos que usamos son secuenciales o no, es el
tratamiento que hagamos de ellos lo que los clasifica como de uno u otro tipo.
Pero hay archivos que se comportan siempre como secuenciales, por ejemplo los ficheros de entrada y salida estndar:
stdin, stdout, stderr y stdaux.

17