CONCEPTOS BASICOS EN

Elaborado por: Zayra Daniela Salas Duran

3
 INDICE

Codigo para generar nmeros

5
aleatorios

Librerias de Dev C++ 5

Librerias String.h 6

Funciones de Dev para el

8
manejo de cadenas

Estructuras (struct) 11

Manejo de struct 12

Manejo de archivos
secuenciales y directos en Dev 15
C++

4
 Codigo para generar un numero aleatorio en Dev c++

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

int main()
{
int i;
for(i=0; i<5; i++)
{
printf("%d\n", rand());
}
return 0;
}

Libreras de Dev C++

iosfwd: Contiene declaraciones adelantadas de todas las plantillas de flujos y sus typedefs
estndar. Por ejemplo ostream.

iostream: Parte del a STL que contiene los algoritmos estndar, es quiz la ms usada e
importante (aunque no indispensable).

Biblioteca new: Manejo de memoria dinmica

Librera stdlib: Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso
general.

typeinfo: Mecanismo de identificacin de tipos en tiempo de ejecucin

forward_list: Esta librera es til para implementar con gran facilidad listas enlazadas simples.

Iterator: Proporciona un conjunto de clases para iterar elementos.

Regex: Proporciona fcil acceso al uso de expresiones regulares para la comparacin de patrones.

Thread: til para trabajar programacin multihilos y crear mltiples hilos en nuestra aplicacin.

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

Iostream:

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.

5
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.

Librera string.h
string.h es un archivo de la Biblioteca estndar del lenguaje de programacin C que contiene
la definicin de macros, constantes, funciones y tipos y algunas operaciones de manipulacin
de memoria.
Las funciones declaradas en string.h se han hecho muy populares, por lo que estn
garantizadas para cualquier plataforma que soporte C. Sin embargo, existen algunos
problemas de seguridad con estas funciones, como el desbordamiento de buffer.

6
7
 Funciones de Dev para el manejo de cadenas

Una cadena en C++ es un conjunto de caracteres, o valores de tipo char, terminados con el
carcter nulo, es decir el valor numrico 0. Internamente, en el ordenador, se almacenan en
posiciones consecutivas de memoria. Este tipo de estructuras recibe un tratamiento muy
especial, ya que es de gran utilidad y su uso es continuo.

La manera de definir una cadena es la siguiente: char <identificador> [<longitud mxima>];

Aunque C no incorpora en su definicin operadores para el manejo de cadenas de caracteres, todo

compilador de C proporciona una librera estndar (string.h) con funciones para facilitar su utilizacin. Destacar
algunas de ellas:

strcpy: La funcin strcpy se encuentra en la biblioteca <string.h> y se utiliza para copiar

una cadena de caracteres (fuente) en el lugar que ocupaba otra (destino). Esta copia es

8
destructiva, o sea, que todos los caracteres que estaban en la cadena destino
desaparecen, aunque la cadena destino fuera ms larga que la cadena fuente .La cadena
destino se pone como primer argumento de la funcin y la cadena fuente como segundo.
Vamos a verlo con un ejemplo.

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

int main()
{
char texto1[]="corta";
char texto2[]="mediana";
char texto3[]="larguisima";

strcpy(texto2,texto1);
printf("%s\n",texto2);
strcpy(texto2,texto3);
printf("%s\n",texto2);
getch();
return 0;
}

strcat: En el programa anterior vimos que la funcin strcpy es desctructiva, pero hay
otra funcin en la librera <string.h> que copia una cadena (fuente) en otra (destino) sin
destruir sta, es decir, que copia una cadena detrs de la otra esta funcin es conocida
como strcat. Vamos a hacer un ejemplo:

#include<stdio.h>
#include<string.h>
int main()
{
char texto1[]="Don Pepito";
char texto2[]=" y ";
char texto3[]="Don Jose";printf("%s\n",texto1);

strcat(texto1,texto2);
printf("%s\n",texto2);
strcat(texto1,texto3);
printf("%s\n",texto2);
getchar();
return 0;
}

strlen: esta funcin devuelve el total (entero) de caracteres que conforman una cadena
(excluyendo el caracter nulo \0). Vamos a hacer un ejemplo:

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

9
#define MAXLON 80

int main(void)
{
char a[MAXLON+1];
int longitud;

clrscr();
printf ("Introduce una cadena (max. %d caracteres): ", MAXLON);
scanf("%s",&a);
longitud = strlen(a);
printf ("\nLongitud de la cadena: %d\n", longitud);
getch();
return 0;
}

strcmp: strcmp (abreviatura de ((string comparison))). La funcin strcmp recibe dos

cadenas, a y b, devuelve un entero. El entero que resulta de efectuar la llamada strcmp(a,
b) codifica el resultado de la comparacin:

es menor que cero si la cadena a es menor que b,

es 0 si la cadena a es igual que b, y

es mayor que cero si la cadena a es mayor que b.

Naturalmente, menor significa que va delante en orden alfabtico, y mayor que va detrs.

#include <stdio.h>
#include <string.h>
int main()
{
char s1[6] = "Abeja";
char s2[6] = "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;
}

10
Otras Funciones tiles para operar cadenas de caracteres.

No slo string.h contiene funciones tiles para el tratamiento de cadenas. En ctype.h se

encuentran unas funciones que permiten hacer cmodamente preguntas acerca de los
caracteres, como si son maysculas, minsculas, dgitos, etc:

isalnum(caracter): devuelve cierto (un entero cualquiera distinto de cero) si caracter es

una letra o dgito, y falso (el valor entero 0) en caso contrario.

isalpha(caracter): devuelve cierto si caracter es una letra, y falso en caso contrario.

isblank(caracter): devuelve cierto si caracter es un espacio en blanco o un tabulador.

isdigit(caracter) devuelve cierto si caracter es un digito, y falso en caso contrario.

isspace(caracter): devuelve cierto si caracter es un espacio en blanco, un salto de lnea,

un retorno de carro, un tabulador, etc., y falso en caso contrario.

islower(caracter): devuelve cierto si caracter es una letra minscula, y falso en caso

contrario.

isupper(caracter): devuelve cierto si caracter es una letra mayscula, y falso en caso

contrario.

toupper(caracter): devuelve la mayscula asociada a caracter, si la tiene; si no, devuelve

el mismo caracter.

tolower(caracter): devuelve la minscula asociada a caracter, si la tiene; si no, devuelve el

mismo caracter.

Estructura (Struct)
Al contrario que los arrays, las estructuras nos permiten agrupar varios datos, que
mantengan algn tipo de relacin, aunque sean de distinto tipo, permitiendo
manipularlos todos juntos, usando un mismo identificador, o cada uno por separado.
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:

11
[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;

Manejo de estructura

Una estructura contiene varios datos. La forma de definir una estructura es haciendo uso de la
palabra clave struct. Aqui hay ejemplo de la declaracion de una estructura:

struct mystruct
{
int int_member;
double double_member;
char string_member[25];
} variable;

"variable" es una instancia de "mystruct" y no es necesario ponerla aqu. Se podria omitir de la

declaracion de "mystruct" y ms tarde declararla usando:

struct mystruct variable;

Tambin es una prctica muy comn asignarle un alias o sinnimo al nombre de la estructura,
para evitar el tener que poner "struct mystruct" cada vez. C nos permite la posibilidad de hacer
esto usando la palabra clave typedef, lo que crea un alias a un tipo:

typedef struct
{
...

12
 } Mystruct;

La estructura misma no tiene nombre (por la ausencia de nombre en la primera linea), pero
tiene de alias "Mystruct". Entonces se puede usar as:

Mystruct variable;

Note que es una convencion, y una buena costumbre usar mayscula en la primera letra de un
sinnimo de tipo. De todos modos lo importante es darle algn identificador para poder hacer
referencia a la estructura: podriamos tener una estructura de datos recursiva de algn tipo.
Ejemplo de una estructura :

/*
* estructura.c
*
* Julio Csar Brizuela <brizuelaalvarado@gmail.com> 2009
*
* para el wikilibro "Programacin en C (fundamentos)"
* bajo licencia FDL, adaptado del Dominio Pblico
*
* Nombre Miembro Tipo
* Titulo char[30]
* Artista char[25]
* Precio float
* Total Canciones int
*/

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

/* definimos una estructura para cds */

struct cd
{
char titulo[30];
char artista[25];
float precio;
int canciones;
} Cd1 = { /* inicializamos la estructura Cd1 crea con sus valores
* usando las definiciones iniciales*/
"Canciones Bebe", /* titulo */
"Pinocho", /* artista */

13
 12.50, /* precio */
16 /* total canciones */
};

int main(void)
{
struct cd Cd2; /* definimos una nueva estructura llamado cd2 */

/* asignamos valores a los tipos de datos del cd2 */

strcpy(Cd2.titulo, "New Age");

/* la forma de insertar valores a un

* tipo char en una estructura es usando strcpy
* de la libreria string.h
*/
strcpy(Cd2.artista, "Old Man");
Cd2.precio = 15.00;
Cd2.canciones = 12;

/* la forma de acceder a los valores de una estructura */

/* es usando el "." despues de la definicion del dato*/
printf("\n Cd 1");
printf("\n Titulo: %s ", Cd1.titulo);
printf("\n Artista: %s ", Cd1.artista);
printf("\n Total Canciones: %d ", Cd1.canciones);
printf("\n Precio Cd: %.2f ", Cd1.precio);

printf("\n");
printf("\n Cd 2");
printf("\n Titulo: %s ", Cd2.titulo);
printf("\n Artista: %s ", Cd2.artista);
printf("\n Total Canciones: %d ", Cd2.canciones);
printf("\n Precio Cd: %.2f ", Cd2.precio); /* el .2 que esta entre
%f
* sirve para mostrar
unicamente
* 2 decimales despues
del punto*/

return 0;

14
}

Manejo de archivos secuenciales y directos en Dev c++

Definicin de archivos secuenciales: Es la forma bsica de organizar un conjunto de

registros, que forman un archivo, utilizando una organizacin secuencial. En un archivo
organizado secuencialmente, lo registros quedan grabados consecutivamente cuando el
archivo se utiliza como entrada.

C define la estructura de datos FILE en el fichero de cabecera stdio.h para el manejo de

ficheros. Nosotros siempre usaremos punteros a estas estructuras.
La definicin de sta estructura depende del compilador, pero en general mantienen
un campo con la posicin actual de lectura/escritura, un buffer para mejorar las
prestaciones de acceso al fichero y algunos campos para uso interno.
Funcin fopen:
Sintaxis:

FILE *fopen(char *nombre, char *modo);

Esta funcin sirve para abrir y crear ficheros en disco. El valor de retorno es un
puntero a una estructura FILE. Los parmetros de entrada son:
1. nombre: una cadena que contiene un nombre de fichero vlido, esto
depende del sistema operativo que estemos usando. El nombre puede
incluir el camino completo.
2. modo: especifica en tipo de fichero que se abrir o se crear y el tipo de
datos que puede contener, de texto o binarios:
o r: slo lectura. El fichero debe existir.
o w: se abre para escritura, se crea un fichero nuevo o se
sobreescribe si ya existe.
o a: aadir, se abre para escritura, el cursor se situa al final del
fichero. Si el fichero no existe, se crea.
o r+: lectura y escritura. El fichero debe existir.
o w+: lectura y escritura, se crea un fichero nuevo o se
sobreescribe si ya existe.
o a+: aadir, lectura y escritura, el cursor se situa al final del
fichero. Si el fichero no existe, se crea.
o t: tipo texto, si no se especifica "t" ni "b", se asume por defecto
que es "t"
o b: tipo binario.

15
Funcin fclose:
Sintaxis:

int fclose(FILE *fichero);

Es importante cerrar los ficheros abiertos antes de abandonar la aplicacin. Esta

funcin sirve para eso. Cerrar un fichero almacena los datos que an estn en el buffer
de memoria, y actualiza algunos datos de la cabecera del fichero que mantiene el
sistema operativo. Adems permite que otros programas puedan abrir el fichero para
su uso. Muy a menudo, los ficheros no pueden ser compartidos por varios programas.
Un valor de retorno cero indica que el fichero ha sido correctamente cerrado, si ha
habido algn error, el valor de retorno es la constante EOF. El parmetro es un
puntero a la estructura FILE del fichero que queremos cerrar.
Funcin fgetc:
Sintaxis:

int fgetc(FILE *fichero);

Esta funcin lee un carcter desde un fichero.

El valor de retorno es el carcter ledo como un unsigned char convertido a int. Si no
hay ningn carcter disponible, el valor de retorno es EOF. El parmetro es un puntero
a una estructura FILE del fichero del que se har la lectura.
Funcin fputc:
Sintaxis:

int fputc(int caracter, FILE *fichero);

Esta funcin escribe un carcter a un fichero.

El valor de retorno es el carcter escrito, si la operacin fue completada con xito, en
caso contrario ser EOF. Los parmetros de entrada son el carcter a escribir,
convertido a int y un puntero a una estructura FILE del fichero en el que se har la
escritura.
Funcin feof:
Sintaxis:

int feof(FILE *fichero);

Esta funcin sirve para comprobar si se ha alcanzado el final del fichero. Muy
frecuentemente deberemos trabajar con todos los valores almacenados en un archivo
de forma secuencial, la forma que suelen tener los bucles para leer todos los datos de
un archivo es permanecer leyendo mientras no se detecte el fin de fichero. Esta funcin
suele usarse como prueba para verificar si se ha alcanzado o no ese punto.
El valor de retorno es distinto de cero slo si no se ha alcanzado el fin de fichero. El
parmetro es un puntero a la estructura FILE del fichero que queremos verificar.

16
Funcin rewind:
Sintaxis:

void rewind(FILE *fichero)

Es una funcin heredada de los tiempos de las cintas magnticas. Literalmente

significa "rebobinar", y hace referencia a que para volver al principio de un archivo
almacenado en cinta, haba que rebobinarla. Eso es lo que hace sta funcin, sita el
cursor de lectura/escritura al principio del archivo.
El parmetro es un puntero a la estructura FILE del fichero que queremos rebobinar.
Ejemplos:

// ejemplo1.c: Muestra un fichero dos veces.

#include <stdio.h>

int main()
{
FILE *fichero;

fichero = fopen("ejemplo1.c", "r");

while(!feof(fichero)) fputc(fgetc(fichero), stdout);
rewind(fichero);
while(!feof(fichero)) fputc(fgetc(fichero), stdout);
fclose(fichero);
getchar();
return 0;
}

Funcin fgets:
Sintaxis:

char *fgets(char *cadena, int n, FILE *fichero);

Esta funcin est diseada para leer cadenas de caracteres. Leer hasta n-1 caracteres o
hasta que lea un retorno de lnea. En este ltimo caso, el carcter de retorno de lnea
tambin es ledo.
El parmetro n nos permite limitar la lectura para evitar derbordar el espacio
disponible en la cadena.
El valor de retorno es un puntero a la cadena leda, si se ley con xito, y es NULL si se
detecta el final del fichero o si hay un error. Los parmetros son: la cadena a leer, el
nmero de caracteres mximo a leer y un puntero a una estructura FILE del fichero del
que se leer.
Funcin fputs:
Sintaxis:

int fputs(const char *cadena, FILE *stream);

17
La funcin fputs escribe una cadena en un fichero. No se aade el carcter de retorno
de lnea ni el carcter nulo final.
El valor de retorno es un nmero no negativo o EOF en caso de error. Los parmetros
de entrada son la cadena a escribir y un puntero a la estructura FILE del fichero donde
se realizar la escritura.
Funcin fread:
Sintaxis:

size_t fread(void *puntero, size_t tamao, size_t nregistros, FILE

*fichero);

Esta funcin est pensada para trabajar con registros de longitud constante. Es capaz
de leer desde un fichero uno o varios registros de la misma longitud y a partir de una
direccin de memoria determinada. El usuario es responsable de asegurarse de que
hay espacio suficiente para contener la informacin leda.
El valor de retorno es el nmero de registros ledos, no el nmero de bytes. Los
parmetros son: un puntero a la zona de memoria donde se almacenarn los datos
ledos, el tamao de cada registro, el nmero de registros a leer y un puntero a la
estructura FILE del fichero del que se har la lectura.
Funcin fwrite:
Sintaxis:

size_t fwrite(void *puntero, size_t tamao, size_t nregistros, FILE

*fichero);

Esta funcin tambin est pensada para trabajar con registros de longitud constante y
forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios registros de
la misma longitud almacenados a partir de una direccin de memoria determinada.
El valor de retorno es el nmero de registros escritos, no el nmero de bytes. Los
parmetros son: un puntero a la zona de memoria donde se almacenarn los datos
ledos, el tamao de cada registro, el nmero de registros a leer y un puntero a la
estructura FILE del fichero del que se har la lectura.
Ejemplo:

// copia.c: Copia de ficheros

// Uso: copia <fichero_origen> <fichero_destino>

#include <stdio.h>

int main(int argc, char **argv) {

FILE *fe, *fs;
unsigned char buffer[2048]; // Buffer de 2 Kbytes
int bytesLeidos;

if(argc != 3) {
printf("Usar: copia <fichero_origen> <fichero_destino>\n");
return 1;

18
 }

// Abrir el fichero de entrada en lectura y binario

fe = fopen(argv[1], "rb");
if(!fe) {
printf("El fichero %s no existe o no puede ser abierto.\n",
argv[1]);
return 1;
}
// Crear o sobreescribir el fichero de salida en binario
fs = fopen(argv[2], "wb");
if(!fs) {
printf("El fichero %s no puede ser creado.\n", argv[2]);
fclose(fe);
return 1;
}
// Bucle de copia:
while((bytesLeidos = fread(buffer, 1, 2048, fe)))
fwrite(buffer, 1, bytesLeidos, fs);
// Cerrar ficheros:
fclose(fe);
fclose(fs);
return 0;
}

Funcin fprintf:
Sintaxis:

int fprintf(FILE *fichero, const char *formato, ...);

La funcin fprintf funciona igual que printf en cuanto a parmetros, pero la salida se
dirige a un fichero en lugar de a la pantalla.
Funcin fscanf:
Sintaxis:

int fscanf(FILE *fichero, const char *formato, ...);

La funcin fscanf funciona igual que scanf en cuanto a parmetros, pero la entrada se
toma de un fichero en lugar del teclado.
Funcin fflush:
Sintaxis:

int fflush(FILE *fichero);

Esta funcin fuerza la salida de los datos acumulados en el buffer de salida del fichero.
Para mejorar las prestaciones del manejo de ficheros se utilizan buffers, almacenes
temporales de datos en memoria, las operaciones de salida se hacen a travs del buffer,
y slo cuando el buffer se llena se realiza la escritura en el disco y se vaca el buffer. En

19
ocasiones nos hace falta vaciar ese buffer de un modo manual, para eso sirve sta
funcin.
El valor de retorno es cero si la funcin se ejecut con xito, y EOF si hubo algn error.
El parmetro de entrada es un puntero a la estructuraFILE del fichero del que se
quiere vaciar el buffer. Si es NULL se har el vaciado de todos los ficheros abiertos.

Manejo de archivos directos en Dev c++

20