Documentos de Académico
Documentos de Profesional
Documentos de Cultura
PLANTEL AGS. 1
J.REFUGIO ESPARZA REYES
Estructuras 13
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();
}
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.
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.
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
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);
#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);
#include <stdio.h>
#include <string.h>
int main()
{
int errnum;
return 0;
}
strlen
size_t strlen(const char *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);
#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 );
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:
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:
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.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;
14
archivo << setiosflags(ios::oct);
archivo << "en base octal es: " << numero << endl;
archivo.close();
return 0;
}
Modos de apertura de archivo
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;
}
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:
//*********************************************************
// 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;
}
17