2. MANUAL C/C++
1Henry Hernandez
Índice
Estructura básica deun programa C/C++.................................................................................... 3
Lectura y escritura en c.......................................................................................................... 4
Funcion printf().................................................................................................................. 4
Función scanf() .................................................................................................................. 6
lectura y escritura C++........................................................................................................... 7
Uso del cout....................................................................................................................... 7
Uso del cin......................................................................................................................... 8
Tipos de datos en C/C++........................................................................................................ 9
Tipos de datos C++ numéricos enteros ................................................................................ 9
Tipos de datos numéricos reales........................................................................................11
Tipo lógico........................................................................................................................12
Tipo carácter extendido.....................................................................................................12
identificadores .....................................................................................................................13
Declaración de variables en C/C++.........................................................................................14
Almacenamientoen memoria...............................................................................................15
Arreglos...............................................................................................................................16
Estructuras...........................................................................................................................18
Funciones enel interior de estructuras...............................................................................19
Inicialización de estructuras...............................................................................................22
Arrays de estructuras ........................................................................................................23
Estructuras anidadas.........................................................................................................24
Bibliotecas olibrerías en C++. Declaración y uso de librerías. Include en C++............................26
¿Qué son exactamente laslibrerías? ..................................................................................26
Sintaxis para declarar Libreríasen C++................................................................................27
Librerías Estandar de C++ (Standar Template Library o STL).................................................27
Bucles o Ciclos en c...............................................................................................................29
La estructura condicional IF...else......................................................................................29
La estructura condicional abierta y cerrada switch ... case...................................................30
El bucle while....................................................................................................................32
El bucle for.......................................................................................................................33
El bucle do...while.............................................................................................................34
3. MANUAL C/C++
2Henry Hernandez
Ficheros...............................................................................................................................35
Tipo FILE:..........................................................................................................................35
Función fopen:..................................................................................................................35
Función fclose:..................................................................................................................36
Tres funcionesjuntas(file,fopen, fclose).............................................................................36
Función fgetc:...................................................................................................................36
Función fputc:...................................................................................................................37
Función feof:.....................................................................................................................37
Función rewind:................................................................................................................37
Función fgets:...................................................................................................................38
Función fputs:...................................................................................................................38
Función fread:...................................................................................................................38
Función fwrite:..................................................................................................................39
Función fprintf:.................................................................................................................39
Función fscanf:..................................................................................................................39
Función fflush:..................................................................................................................39
Función fseek:...................................................................................................................40
Función ftell:.....................................................................................................................40
Funciones:............................................................................................................................40
sintaxis de una funciónes la siguiente:...............................................................................41
Paso de Parámetros ..........................................................................................................42
Por Valor..........................................................................................................................42
Variables locales y globales ...................................................................................................42
Una variable local..............................................................................................................42
Una variable global............................................................................................................42
Anexos.....................................................................................................................................43
Ejercicio de estructura..........................................................................................................43
Ficheros...............................................................................................................................44
ejercicios switch ciclosy funciones ........................................................................................45
4. MANUAL C/C++
3Henry Hernandez
ESTRUCTURA BÁSICA DE UN PROGRAMA C/C++
La mejor forma de aprender un lenguaje es programando con él; en la clase de laboratorio
de programación I usaremos el IDE Code::Blocks.
5. MANUAL C/C++
4Henry Hernandez
LECTURA Y ESCRITURA EN C
Para poder leer y escribir datos en el lenguaje de
programación C existen una serie de funciones
agrupadas en un conjunto de librerías de código
objeto, que constituyen la llamada biblioteca
estándar del lenguaje. En el caso concreto de las
funciones de entrada y salida (lectura y escritura), su archivo de cabecera es stdio.h.
Existen varias funciones que realizan la entrada y salida de datos en el lenguaje de
programación C, pero nos vamos a centrar solamente en dos de ellas: printf() y scanf().
FUNCION PRINTF()
La función printf() sirve para escribir datos en la pantalla con un formato determinado.El
prototipo de esta función es la siguiente:
6. MANUAL C/C++
5Henry Hernandez
int printf(const char *formato, arg1, arg2, …, argn)
donde:
formato:
Hace referencia a una cadena de caracteres que contiene información sobre el formato de
salida.
Arg1, arg2, …, argn: argumentos que representan los datos de salida
La cadena de control puede constar de hasta tres tipos de información:
por pantalla tal cual este escrito
'
y las más importantes son 'n' que introduce un salto de línea, y 't' que introduce un
tabulador.
n ciertos caracteres precedidos del carácter tanto por
ciento '%'.
A continuación semuestra una tabla con estos especificadores de formato dependiendo del
tipo de dato a los que representan:
Tipo de dato Especificadores de
formato
Comentario
Int %d Entero con signo
Float %f Real con signo
Char %c carácter
Char [n] %s Cadena de caracteres
7. MANUAL C/C++
6Henry Hernandez
FUNCIÓN SCANF()
La función scanf() se pude considerar de alguna manera como la inversa de la función
printf(), pues sirve para introducir datos desde el teclado con un formato determinado.
El prototipo de esta función es el siguiente:
int scanf(const char *formato, arg1, arg2, …, argn);
donde:
formato: hace referencia a una cadena de caracteres (cadena de control) que
contiene información sobre elformato de los datos que sevan aintroducir mediante
el teclado.
arg1, arg2, …, argn: son los argumentos que representan los datos de entrada.
La cadena de control puede constar de:
Especificadores de formato, que son ciertos caracteres precedido por el carácter
tanto por ciento '%'.
Caracteres de espacio
una tabla con estos especificadores de formato dependiendo del tipo de dato a los
que representan:
Tipo de dato Especificadores de formato Comentario
Int %d Entero con signo
Float %f Real con signo
Char %c carácter
Char [n] %s Cadena de caracteres
8. MANUAL C/C++
7Henry Hernandez
LECTURA Y ESCRITURA C++
USO DEL COUT
Biblioteca de entrada y salida fluidas "iostream"
En el contexto de C++ todo lo referente a
"streams" puede visualizarse mejor si usamos un
símil como un río o canal de agua.
Imagina un canal por el que circula agua, si
echamos al canal objetos que floten, estos se
moverán hasta el final de canal, siguiendo el flujo
del agua. Esta es la idea que se quiere transmitir cuando se llama "stream" a algo en C++.
Por ejemplo, en C++ el canal de salida es cout, los objetos flotantes serán los argumentos
que queremos extraer del ordenador o del programa, la salida del canal es la pantalla.
Sintaxis:
cout << <variable/constante> [<< <variable/constante>...];
Completando el símil, en la orden:
cout << "hola" << " " << endl;
9. MANUAL C/C++
8Henry Hernandez
Los operadores "<<" representarían el agua, y la dirección en que se mueve. Cualquier cosa
que soltemos en el agua: "hola", " " o endl, seguirá flotando hasta llegar a la pantalla, y
además mantendrán su orden.
USO DEL CIN
En esta biblioteca se definen algunas de las funciones aplicables a los "streams", pero aún
no estamos en disposición de acceder a ellas. Baste decir de momento que existen cuatro
"streams" predeterminados:
cin, canal de entrada estándar.
cout, canal de salida estándar.
cerr, canal de salida de errores.
clog, canal de salida de diario o anotaciones.
Sobre eluso de cin,que es el único canal de entrada predefinido, tenemos que aclararcómo
se usa, aunque a lo mejor ya lo has adivinado.
cin >> <variable> [>> <variable>...];
Donde cada variable irá tomando el valor introducido mediante el teclado. Los espacios y
los retornos de línea actúan como separadores.
Ejemplo:
10. MANUAL C/C++
9Henry Hernandez
Escribir un programa que lea el nombre, la edad y el número de teléfono de un usuario y
los muestre en pantalla.
TIPOS DE DATOS EN C/C++
TIPOS DE DATOS C++ NUMÉRICOS ENTEROS
Eltipo de dato numérico entero es un subconjunto finito de los números enteros del mundo
real. Pueden ser positivos o negativos. En C++ los tipos de datos numéricos enteros son los
siguientes:
11. MANUAL C/C++
10Henry Hernandez
Tipo de Dato Descripción
Número de bytes
típico
Rango
short Entero corto 2 -32768 a 32767
int Entero 4 -2147483648 a +2147483647
long Entero largo 4 -2147483648 a +2147483647
char Carácter 1 -128 a 127
Con los tipos enteros pueden utilizarse los calificadores signed y unsigned. Estos
calificadores indican si el número tiene signo o no. Si se usan solos, sin indicar el tipo de
dato se asume int.
Por ejemplo, las siguientes declaraciones son equivalentes:
unsigned int x; equivale a: unsigned x;
12. MANUAL C/C++
11Henry Hernandez
Usando estos calificadores podemos tener los siguientes tipos enteros:
Podemos ver que los datos enteros de tipo signed son equivalentes a los enteros sin utilizar
el calificador:
signed int a; es equivalente a escribir int a;
TIPOS DE DATOS NUMÉRICOS REALES
El tipo de dato numérico real es un subconjunto finito de los números reales. Pueden ser
positivos o negativos.
En C++ los tipos de datos numéricos reales son los siguientes:
Tipo de
Dato
Descripción
Número de
bytes típico
Rango
Tipo de Dato Descripción
Número de
bytes típico
Rango
signed short Entero corto 2 -32768 a 32767
unsigned short Entero corto sin signo 2 0 a 65535
signed int Entero 4 -2147483648 a +2147483647
unsigned int Entero sin signo 4 0 a 4294967295
signed long Entero largo 4 -2147483648 a +2147483647
unsigned long Entero largo sin signo 4 0 a 4294967295
signed char Carácter 1 -128 a 127
unsigned char Carácter sin signo 1 0 a 255
13. MANUAL C/C++
12Henry Hernandez
float
Real (Número en coma
flotante)
4
Positivos: 3.4E-38 a 3.4E38
Negativos: -3.4E-38 a -3.4E38
double
Real doble(Número en
coma flotante de doble
precisión)
8
Positivos: 1.7E-308 a 1.7E308
Negativos: -1.7E-308 a -1.7E308
long double Real doble largo 10
Positivos: 3.4E-4932 a 1.1E4932
Negativos: -3.4E-4932 a -1.1E4932
TIPO LÓGICO
Los datos de este tipo sólo pueden contener dos valores: true ó false (verdadero ó falso). Si
se muestran como enteros, el valor true toma el valor 1 y false el valor 0.
Tipo de
Dato
Descripción
Número de
bytes típico
Rango
bool Dato de tipo lógico 1 0, 1
TIPO CARÁCTER EXTENDIDO
Estetipo seutiliza para representar caracteres UNICODE.Utiliza 2 bytes a diferencia del tipo
char que solo utiliza 1.
Tipo de
Dato
Descripción
Número de
bytes típico
Rango
wchar_t Carácter Unicode 2 0 a 65535
14. MANUAL C/C++
13Henry Hernandez
IDENTIFICADORES
Un identificador es una secuencia de caracteres alfabéticos, numéricos y el guión bajo. Con
ellos podemos dar nombre a variables, constantes, tipos de dato, nombres de funciones o
procedimientos, etcétera. Cada lenguaje de programación tiene sus propias características
del tamaño del identificador; el estándar de lenguaje C no especifica un límite de tamaño
para un identificador, pero para ciertas implementaciones de C11 sólo los primeros 31
caracteres son significativos (ANSI C). El programador tiene libertad para darle cualquier
nombre a un identificador, siguiendo estas reglas:
1. Debe comenzar con una letra (A aZ)mayúscula o minúscula y no puede contener espacios
en blanco.
En lenguaje C, el carácter “_” (guión bajo) es considerado como letra, por lo que se puede
utilizar como primer carácter.
2. El lenguaje C distingue mayúsculas de minúsculas porque tienen diferente código ASCII.
3. Letras, dígitos y el carácter guión bajo están permitidos después del primer carácter.
4. No pueden existir dos identificadores iguales, es decir, dos elementos de un programa no
pueden nombrarse de la misma forma. Sin embargo, un identificador puede aparecer más
de una vez en un programa.
5. No se puede utilizar una palabra reservada como identificador, sin embargo, los
identificadores estándar se pueden redefinir.
6. En lenguaje C existen identificadores que podrían tener uno o varios puntos, tales como:
persona.apellidoPaterno
El punto indica el acceso a un campo de una estructura.
Sugerencias:
1. El identificador debe tener un nombre que sea significativo, es decir, que dé una idea de
la información que almacena.
2. No utilizar nombres muy largos, es mejor utilizar abreviaturas estándar para que éstos
tengan una longitud razonable.
3. En lenguaje C es usual escribir variables en minúscula, dejando las mayúsculas para las
constantes. En
los casos de nombres compuestos se suele poner la inicial de la segunda palabra en
mayúscula.
15. MANUAL C/C++
14Henry Hernandez
DECLARACIÓN DE VARIABLES EN C/C++
Una característica de C++, es la necesidad de declarar las variables que se usarán en un
programa. Esto resulta chocante para los que se aproximan al C++ desde otros lenguajes de
programación en los que las variables de crean automáticamente la primera vez que se
usan. Se trata, es cierto, de una característica de bajo nivel, más cercana al ensamblador
que a lenguajes de alto nivel, pero en realidad una característica muy importante y útil de
C++, ya que ayuda a conseguir códigos más compactos y eficaces, y contribuye a facilitar la
depuración y la detección y corrección de errores y a mantener un estilo de programación
elegante.
Uno de los errores más comunes en lenguajes en los que las variables se crean de forma
automática se produce al cometer errores ortográficos. Por ejemplo, en un programa
usamos una variable llamada prueba, y en un punto determinado le asignamos un nuevo
valor, pero nos equivocamos y escribimos prueba. El compilador o intérprete no detecta el
error, simplemente crea una nueva variable, y continúa como si todo estuviese bien.
En C++ esto no puede pasar, yaque antes de usar cualquier variable es necesario declararla,
y si por error usamos una variable que no ha sido declarada, se producirá un error de
compilación.
La declaración de variables es uno de los tipos de sentencia de C++. La prueba más clara de
esto es que la declaración terminará con un ";". Sintaxis:
También es posible inicializar las variables dentro de la misma declaración. Por ejemplo:
int a = 1234;
bool seguir = true, encontrado;
Declararía las variables a, seguir y encontrado; y además iniciaría los valores de a y seguir
con los valores 1234 y true, respectivamente.
En C++, contrariamente a lo que sucede con otros lenguajes de programación, las variables
no inicializadas tienen un valor indeterminado (con algunas excepciones que veremos más
tarde), y contienen lo que normalmente se denomina "basura". Cuando se declara una
variable se reserva un espacio de memoria para almacenarla, pero no se hace nada con el
contenido de esa memoria, se deja el valor que tuviera previamente, y ese valor puede
interpretarse de distinto modo, dependiendo del tipo.
<Tipo> <lista de variables>;
16. MANUAL C/C++
15Henry Hernandez
ALMACENAMIENTO EN MEMORIA
A continuación, se muestran algunos ejemplos de declaración de variables en lenguaje C.
Ejemplo 1: Ladeclaración de una variable para almacenar laedad de una persona seescribe:
int edad;
Ejemplo 2: Para declarar varias variables del mismo tipo de dato se puede escribir:
int edad;
int numero_de_hijos;
Ejemplo 3: O también, en la misma línea separadas por el carácter coma (,):
int edad, numero_de_hijos;
17. MANUAL C/C++
16Henry Hernandez
Ejemplo 4: Si se desea declarar una variable para almacenar un número entero y que,
inicialmente, contenga el valor 35, se debe escribir:
int numero = 35;
Ejemplo 5: A continuación, se muestra la declaración de una variable para almacenar una
letra del alfabeto y que, inicialmente, contenga el valor 'Z':
char letra = 'Z';
ARREGLOS
Para declarar una variable que pueda almacenar el nombre de una persona y que,
inicialmente, contenga el valor "Isabel", escribiremos:
char nombre[7] = "Isabel";
Un dato de tipo cadena es un dato compuesto (estructurado), debido a que está formado
por una agrupación de caracteres. Pues bien, dicha agrupación se define por medio de un
array. Un array agrupa, bajo el mismo nombre de variable, a una colección de elementos
(datos) del mismo tipo.
Para declarar un array de caracteres, después del identificador de la variable, se tiene que
escribir, entre corchetes "[]", el número de caracteres que se van a almacenar en el array,
más uno. Por tanto, en este caso, puesto que "Isabel" tiene seis caracteres, hay que escribir
un 7 entre los corchetes.
18. MANUAL C/C++
17Henry Hernandez
Se tiene que escribir un número más, porque en la memoria se va a reservar espacio para
los seis caracteres de la cadena "Isabel", más uno, conocido éste como el carácter nulo, el
cual se representa mediante una barra invertida y un cero (0). El sistema se encarga de
"poner" dicho carácter, que indica el fin de la cadena.
Por consiguiente, en la memoria se almacenarán siete caracteres consecutivos:
Los caracteres del array pueden ser referenciados mediante el identificador del mismo,
seguido de un número entre corchetes. A dicho número, de manera formal, se le llama
"índice", y puede oscilarentre el valor 0 y n-1, siendo n el número de caracteres que pueden
ser almacenados en memoria en el array, en este caso 7.
<nombre_de_la_variable>[<índice>]
Por ejemplo, nombre[3] hace referencia al espacio de memoria donde está el carácter 'b'.
Si se declara la variable de tipo cadena:
char nombre[7] = "June";
En memoria tendremos:
19. MANUAL C/C++
18Henry Hernandez
Fíjese que, en esta ocasión, el array de caracteres nombre ha sido inicializado con el valor
"June". De manera que, el fin de la cadena se encuentra en nombre[4], y no en el último
espacio de memoria reservado para el array, ya que, "June" tiene, solamente, cuatro
caracteres.
ESTRUCTURAS
Las estructuras son el segundo tipo de datos estructurados que veremos (valga la
redundancia).
Al contrario que los arrays, las estructuras nos permiten agrupar varios datos, que
mantengan algún tipo de relación, aunque sean de distinto tipo, permitiendo manipularlos
todos juntos, usando un mismo identificador, o cada uno por separado.
Las estructuras son llamadas también muy a menudo registros, o en inglés records. Tienen
muchos aspectos en común con los registros usados en bases dedatos. Y siguiendolamisma
analogía, cada objeto de una estructura se denomina a menudo campo, o field.
Sintaxis:
struct [<identificador>] {
[<tipo> <nombre_objeto>[,<nombre_objeto>,...]];
} [<objeto_estructura>[,<objeto_estructura>,...];
20. MANUAL C/C++
19Henry Hernandez
El identificador de la estructura es un nombre opcional para referirse a la estructura.
Los objetos de estructura son objetos declarados del tipo de la estructura, y su inclusión
también es opcional. Sin bien, aún siendo ambos opcionales, al menos uno de estos
elementos debe existir.
En el interior de una estructura, entre las llaves, se pueden definir todos los elementos que
consideremos necesarios, del mismo modo que se declaran los objetos.
Las estructuras pueden referenciarse completas, usando su nombre, como hacemos con los
objetos que ya conocemos, y también se puede acceder a los elementos definidos en el
interior de la estructura, usando el operador de selección (.), un punto.
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 más
objetos del tipo de estructura en cualquier parte del programa. Para ello usaremos la forma
normal de declaración de objetos, es decir:
[struct] <identificador> <objeto_estructura>
[,<objeto_estructura>...];
En C++ la palabra struct es opcional en la declaración de objetos, al contrario de lo que
sucede en C, en el que es obligatorio usarla.
Ejemplo:
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;
FUNCIONES EN EL INTERIOR DE ESTRUCTURAS
21. MANUAL C/C++
20Henry Hernandez
C++, permite incluir funciones en el interior de las estructuras. Normalmente estas
funciones tienen la misión de manipular los datos incluidos en la estructura, y su uso está
muy relacionado con la programación orientada a objetos.
Aunque esta característica se usa casi exclusivamente con las clases, como veremos más
adelante, también puede usarse en las estructuras. De hecho, en C++, las diferencias entre
estructuras y clases son muy tenues.
Dos funciones muy particulares son las de inicialización, o constructor, y el destructor.
Veremos con más detalle estas funciones cuando asociemos las estructuras y los punteros.
El constructor es una función sin tipo de retorno y con el mismo nombre que la estructura.
El destructor tiene la misma forma, salvo que el nombre va precedido el símbolo "~".
Nota: para aquellos que usen un teclado español, el símbolo "~" se obtiene pulsando las
teclas del teclado numérico 1, 2, 6, mientras se mantiene pulsada la tecla ALT, ([ALT]+126).
También mediante la combinación [Atl Gr]+[4] y un espacio (la tecla [4] de la zona de las
letras, no del teclado numérico).
Veamos un ejemplo sencillo para ilustrar el uso de constructores:
Forma 1:
22. MANUAL C/C++
21Henry Hernandez
Forma 2:
Si no usáramos un constructor, los valores de x e y para Punto1 y Punto2 estarían
indeterminados, contendrían la "basura" que hubiese en la memoria asignada a estas
estructuras durante la ejecución. Con las estructuras éste será el caso más habitual, ya que
sinecesitamos usarconstructores para asignarvalores iniciales,serámucho más lógico usar
clases que estructuras.
Mencionar aquí, sólo a título de información, que el constructor no tiene por qué ser único.
Se pueden definir varios constructores, pero veremos esto mucho mejor y con más detalle
cuando veamos las clases.
Usando constructores nos aseguramos los valores iniciales para los elementos de la
estructura. Veremos que esto puede ser una gran ventaja, sobre todo cuando combinemos
estructuras con punteros, en capítulos posteriores.
También podemos incluir otras funciones, que sedeclaran y definen como las funciones que
ya conocemos.
23. MANUAL C/C++
22Henry Hernandez
Otro ejemplo:
En este ejemplo podemos ver cómo sedefine una estructura con dos campos enteros, y dos
funciones para modificar y leer sus valores. El ejemplo es muy simple, pero las funciones de
guardar valores sepueden elaborar para que no permitan determinados valores, o para que
hagan algún tratamiento de los datos.
Por supuesto se pueden definir otras funciones y también constructores más elaborados e
incluso, redefinir operadores. Y en general, las estructuras admiten cualquiera de las
características de las clases, siendo en muchos aspectos equivalentes.
Veremos estas características cuando estudiemos las clases, y recordaremos cómo
aplicarlas a las estructuras.
INICIALIZACIÓN DE ESTRUCTURAS
De un modo parecido al que se inicializan los arrays, se pueden inicializar estructuras, tan
sólo hay que tener cuidado con las estructuras anidadas. Por ejemplo:
24. MANUAL C/C++
23Henry Hernandez
Cada nueva estructura anidada deberá inicializarse usando la pareja correspondiente de
llaves "{}", tantas veces como sea necesario.
ARRAYS DE ESTRUCTURAS
Lacombinación de las estructuras con los arrays proporciona una potente herramienta para
el almacenamiento y manipulación de datos.
Ejemplo:
25. MANUAL C/C++
24Henry Hernandez
Vemos en este ejemplo lo fácil que podemos declarar el array Plantilla que contiene los
datos relativos a doscientas personas.
Podemos acceder a los datos de cada uno de ellos:
cout << Plantilla[43].Direccion;
O asignar los datos de un elemento de la plantilla a otro:
Plantilla[0] = Plantilla[99];
ESTRUCTURAS ANIDADAS
También está permitido anidar estructuras, con lo cual se pueden conseguir
superestructuras muy elaboradas.
26. MANUAL C/C++
25Henry Hernandez
Ejemplo:
En general, no es una práctica corriente definir estructuras dentro de estructuras, ya que
tienen un ámbito local, y para acceder a ellas se necesita hacer referencia a la estructura
más externa.
Por ejemplo para declarar un objeto del tipo stNombre hay que utilizar el operador de
acceso (::):
stPersona::stNombre NombreAuxiliar;
Sin embargo para declarar un objeto de tipo stDireccion basta con declararla:
stDireccion DireccionAuxiliar;
27. MANUAL C/C++
26Henry Hernandez
BIBLIOTECAS O LIBRERÍAS EN C++. DECLARACIÓN Y USO DE LIBRERÍAS. INCLUDE EN C++
Junto con los compiladores de C y C++, seincluyen ciertos archivos llamados bibliotecas mas
comúnmente librerías. Las bibliotecas contienen el código objeto de muchos programas
que permiten hacer cosas comunes, como leer el teclado, escribir en la pantalla, manejar
números, realizar funciones matemáticas, etc.
Las bibliotecas están clasificadas por el tipo de trabajos que hacen, hay bibliotecas de
entrada y salida, matemáticas, de manejo de memoria, de manejo de textos y como
imaginarás existen muchísimas librerías disponibles y todas con una función especifica.
Nota: Existe una discusión sobre el nombre de estos archivos. Muchos personas consideran
que el nombre adecuado es archivos de biblioteca, y estan en lo correcto. Sin embargo, la
mayoría llamamos a estos archivos librerías, y también me incluyo entre estos. El error
proviene del nombre en inglés, que es library. Este término se traduce como biblioteca, y
no como librería. De este modo a lo largo de esta sección las llamaré de cualquiera de las
dos formas, para estár mas claros.
Hay un conjunto de bibliotecas (o librerías) muy especiales, que se incluyen con todos los
compiladores de C y de C++. Son las librerías (o bibliotecas) ANSI o estándar. También hay
librerías que no son parte del estándar pero en esta sección sólo usaremos algunas
bibliotecas (o librerías) ANSI.
Nota 2: Sé que esto pinta aburrido, pero es muy útil y realmente las libreróas nos facilitan
enormemente el trabajo de programar. Recuerda que antes de hablar librerías y demás es
necesario dominar algunos conceptos de fundamentación en general y otros temas
importantes (ciclos, condicionales y demás) Ahora veamos algunas librerías y como es su
sintaxis.
¿QUÉ SON EXACTAMENTE LAS LIBRERÍAS?
En C++, se conoce como librerías (o bibliotecas) a cierto tipo de archivos que podemos
importar o incluir en nuestro programa. Estos archivos contienen las especificaciones de
diferentes funcionalidades ya construidas y utilizables que podremos agregar a nuestro
programa, como por ejemplo leer del teclado o mostrar algo por pantalla entre muchas
otras más.
Al poder incluir estas librerías con definiciones de diferentes funcionalidades podremos
ahorrarnos gran cantidad de cosas, imaginemos por ejemplo que cada vez que necesitemos
leer por teclado, debamos entonces crear una función que lo haga (algo realmente
complejo), al poder contar con las librerías en C++, podremos hacer uso de una gran
28. MANUAL C/C++
27Henry Hernandez
variedad de funciones que nos facilitaran la vida y aumentarán la modularidad de nuestros
códigos.
Las librerías no son únicamente archivos externos creados por otros, también es posible
crear nuestras propias librerías y utilizarlas en nuestros programas. Las librerías pueden
tener varias extensiones diferentes, las más comunes son: .lib, .bpl, .a, .dll, .h y algunas más
ya no tan comunes.
En conclusión: Las librearías son archivos (no siempre externos) que nos permiten llevar a
cabo diferentes tareas sin necesidadde preocuparnos por cómo sehacen sino simplemente
entender cómo usarlas. Las librearías en C++ permiten hacer nuestros programas más
modulares y reutilizables, facilitando además crear programas con funcionalidades
bastante complejas en unas pocas líneas de código.
SINTAXIS PARA DECLARAR LIBRERÍAS EN C++
La declaración de librerías, tanto en C como en C++, se debe hacer al principio de todo
nuestro código, antes de la declaración de cualquier función o línea de código, debemos
indicarle al compilador que librerías usar, para el saber que términos estaran correctos en
la escritura de nuestro código y cuáles no. La sintaxis es la siguiente: #include <nombre de
la librería> o alternativamente #include "nombre de la librería". Cualquiera de las 2 formas
es válida en C++ (no estoy seguro si en C sea válido), ten en cuenta que siempre el nombre
de la librería debe ir entre " y " o entre < y >. En tu código puedes declarar todas las librerías
que quieras aunque en realidad no tienen sentido declarar una librería que no vas a usar en
tu programa, sin embargo no existe límite para esto.
LIBRERÍAS ESTANDAR DE C++ (STANDAR TEMPLATE LIBRARY O STL)
A continuación pondré algunas delas librerías de uso más común de C++y que forman parte
de las librerías estandar de este lenguaje.
fstream:
Flujos hacia/desde ficheros. Permite la manipulación de archivos desde el programar, tanto
leer como escribir en ellos.
iosfwd:
Contiene declaraciones adelantadas de todas las plantillas deflujos y sus typedefs estándar.
Por ejemplo ostream.
iostream:
29. MANUAL C/C++
28Henry Hernandez
Parte del a STL que contiene los algoritmos estándar, es quizá la más usada e importante
(aunque no indispensable).
La biblioteca list:
Parte de la STL relativa a contenedores tipo list; listas doblemente enlazadas
math:
Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación de
funciones matemáticas.
memory:
Utilidades relativas a la gestión de memoria, incluyendo asignadores y punteros inteligentes
(auto_ptr).
"auto_ptr" es una clase que conforma la librería memory y permite un fácil manejo
de punteros y su destrucción automaticamente.
Biblioteca new:
Manejo de memoria dinámica
numeric:
Parte de la librería numérica de la STL relativa a operaciones numéricas.
ostream:
Algoritmos estándar para los flujos de salida.
queue:
Parte de la STL relativa a contenedores tipo queue (colas de objetos).
Librería stdio:
Contiene los prototipos de las funciones, macros, y tipos para manipular datos de
entrada y salida.
Librería stdlib:
Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso general.
30. MANUAL C/C++
29Henry Hernandez
string:
Parte de la STL relativa a contenedores tipo string; una generalización de las cadenas
alfanuméricas para albergar cadenas de objetos. Muy útil para el fácil uso de las cadenas de
caracteres, pues elimina muchas d elas dificultades que generan los char
typeinfo:
Mecanismo de identificación de tipos en tiempo de ejecución
vector:
Parte de la STL relativa a los contenedores tipo vector; una generalización de las matrices
unidimensionales C/C++
forward_list
Esta librería es útil para implementar con gran facilidad listas enlazadas simples.
list
Permite implementar listas doblemente enlzadas (listas enlazadas dobles) facilmente.
iterator
Proporciona un conjunto de clases para iterar elementos.
regex
Proporciona fácil acceso al uso de expresiones regulares para la comparación de patrones.
thread
Útil para trabajar programación multihilos y crear múltiples hilos en nuestra aplicación.
BUCLES O CICLOS EN C
LA ESTRUCTURA CONDICIONAL IF... ELSE
La estructura condicional if ... else es la que nos permite tomar ese tipo de decisiones.
Traducida literalmente del inglés, se la podría llamar la estructura "si...si no", es decir, "si se
cumple la condición, haz esto, y sino, haz esto otro".
31. MANUAL C/C++
30Henry Hernandez
Un ejemplo sencillo sería el siguiente (no se trata de un programa completo, sino tan sólo
una porción de código):
LA ESTRUCTURA CONDICIONAL ABIERTA Y CERRADA SWITCH ... CASE
La estructura condicional switch ... case se utiliza cuando queremos evitarnos las llamadas
escaleras de decisiones. La estructura if nos puede proporcionar, únicamente, dos
resultados, uno para verdadero y otro para falso. Una estructura switch ... case, por su
parte, nos permite elegir entre muchas opciones. Ejemplo:
32. MANUAL C/C++
31Henry Hernandez
Laestructura anterior, de realizarsecon sentencias if,necesitaríacuatro de ellas,resultando
un enorme bloque muy difícil de leer. En la mayoría de los casos, además, la sentencia
switch proporciona una ganancia en velocidad del código, pues permite al compilador
trabajar en base a que se trata de una decisión múltiple para una única variable, cosa que
con sentencias if el compilador no tiene por qué detectar.
Como vemos, para cada valor de la variable se ejecuta un bloque de sentencias distinto, en
el que no necesitamos llaves. Hay un caso especial, default, que se ejecuta si ningún otro
corresponde, y que no es necesario poner. Es, en todo, equivalente al bloque else de una
sentencia if.
Las sentencias break son muy importantes, ya que el comportamiento normal de un bloque
switch es ejecutarlo todo desde la etiqueta case que corresponda hasta el final. Por ello, si
no queremos que se nos ejecute más de un bloque, pondremos sentencias break al final de
cada bloque excepto el último.
33. MANUAL C/C++
32Henry Hernandez
Es decir, las etiquetas case son puntos de entrada de la ejecución, y no implican que al
acabarse el bloque case la ejecución salte al final del bloque switch. Las etiquetas case
siguientes a la que hemos utilizado para entrar son, sencillamente, ignoradas.
EL BUCLE WHILE
El bucle while sirve para ejecutar código reiteradas veces.
La condición debe de ser una expresión lógica, similar a la de la sentencia if. Primero se
evalúa la condición. Si el resultado es verdadero, se ejecuta el bloque de código. Luego se
vuelve a evaluar la condición, y en caso de dar verdadero se vuelve a ejecutar el bloque. El
bucle se corta cuando la condición da falso.
Ejemplo: imprimir los números de 0 a 99:
34. MANUAL C/C++
33Henry Hernandez
EL BUCLE FOR
El bucle for es un bucle muy flexible y a la vez muy potente ya que tiene varias formas
interesantes de implementarlo, su forma más tradicional es la siguiente:
Inicialización: en esta parte se inicia la variable que controla el bucle y es la primera
sentencia que ejecuta el bucle. Sólo se ejecuta una vez ya que solo se necesita al principio
del bucle.
Expresión condicional: al igual que en el bucle while, esta expresión determina si el bucle
continuará ejecutándose o no.
Incremento: es una sentenciaque ejecuta alfinal de cadaiteración del bucle. Por lo general,
se utiliza para incrementar la variable con que se inicio el ciclo. Luego de ejecutar el
incremento, el bucle revisa nuevamente la condición, si es verdadera tiene lugar una
ejecución más del cuerpo del ciclo, si es falsa se termina el ciclo y así.
Aquí se muestra el mismo ejemplo visto para el bucle while, pero implementado con un
bucle for:
35. MANUAL C/C++
34Henry Hernandez
EL BUCLE DO...WHILE
El bucle do...while es un bucle que, por lo menos, se ejecuta una vez. Do significa
literalmente "hacer", y while significa "mientras"
Su forma es esta:
La verdad es que este ejemplo puede resultar un poco absurdo, pero es bastante intuitivo.
El código del bucle asignaun valor aleatorio a lavariable definida anteriormente, y mientras
esa variable no tenga el valor 25, el bucle sigue ejecutándose.
36. MANUAL C/C++
35Henry Hernandez
. Sólo en ocasiones muy excepcionales será recomendado eluso del goto alcrear iteraciones
muy complejas. Sin embargo, con el pasar de los años este comando ya ha quedado
prácticamente descartado del lenguaje de los programadores.
FICHEROS
TIPO FILE:
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 definición de ésta estructura depende del compilador, pero en general mantienen un
campo con la posición actual de lectura/escritura, un buffer para mejorar las prestaciones
de acceso al fichero y algunos campos para uso interno.
FUNCIÓN FOPEN:
Sintaxis:
FILE *fopen(char *nombre, char *modo);
Esta función sirve para abrir y crear ficheros en disco. El valor de retorno es un puntero a
una estructura FILE. Los parámetros de entrada son:
Nombre: una cadena que contiene un nombre de fichero válido, esto depende del sistema
operativo que estemos usando. El nombre puede incluir el camino completo.
Modo: especifica en tipo de fichero que se abrirá o se creará y el tipo de datos que puede
contener, de texto o binarios:
r: sólo lectura. El fichero debe existir.
w: se abre para escritura, se crea un fichero nuevo o se sobrescribe si ya existe.
a: añadir, se abre para escritura, el cursor se sitúa al final del fichero. Si el fichero no existe,
se crea.
r+: lectura y escritura. El fichero debe existir.
w+: lectura y escritura, se crea un fichero nuevo o se sobrescribe si ya existe.
a+: añadir, lectura y escritura, el cursor se sitúa al final del fichero. Si el fichero no existe, se
crea.
t: tipo texto, si no se especifica "t" ni "b", se asume por defecto que es "t"
37. MANUAL C/C++
36Henry Hernandez
b: tipo binario.
FUNCIÓN FCLOSE:
Sintaxis:
int fclose(FILE *fichero);
Es importante cerrar los ficheros abiertos antes de abandonar la aplicación. Esta función
sirve para eso. Cerrar un fichero almacena los datos que aún están en el buffer de memoria,
y actualiza algunos datos de la cabecera del fichero que mantiene el sistema operativo.
Además 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
algún error, el valor de retorno es la constante EOF. El parámetro es un puntero a la
estructura FILE del fichero que queremos cerrar.
TRES FUNCIONES JUNTAS (FILE,FOPEN, FCLOSE)
Ahí podemos ver cómo hacemos una comprobación para ver si lo creamos bien
FUNCIÓN FGETC:
Sintaxis:
int fgetc(FILE *fichero);
38. MANUAL C/C++
37Henry Hernandez
Esta función lee un carácter desde un fichero.
El valor de retorno es el carácter leído como un unsigned char convertido a int. Si no hay
ningún carácter disponible, el valor de retorno es EOF. El parámetro es un puntero a una
estructura FILE del fichero del que se hará la lectura.
FUNCIÓN FPUTC:
Sintaxis:
int fputc(int caracter, FILE *fichero);
Esta función escribe un carácter a un fichero.
El valor de retorno es el carácter escrito, si la operación fue completada con éxito, en caso
contrario será EOF. Los parámetros de entrada son el carácter a escribir, convertido a int y
un puntero a una estructura FILE del fichero en el que se hará la escritura.
FUNCIÓN FEOF:
Sintaxis:
int feof(FILE *fichero);
Esta función 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 función suele
usarse como prueba para verificar si se ha alcanzado o no ese punto.
El valor de retorno es distinto de cero sólo si no se ha alcanzado el fin de fichero. El
parámetro es un puntero a la estructura FILE del fichero que queremos verificar.
FUNCIÓN REWIND:
Sintaxis:
void rewind(FILE *fichero)
Es una función heredada de los tiempos de las cintas magnéticas. Literalmente significa
"rebobinar", y hace referencia a que para volver al principio de un archivo almacenado en
cinta, había que rebobinarla. Eso es lo que hace ésta función, sitúa el cursor de
lectura/escritura al principio del archivo.
El parámetro es un puntero a la estructura FILE del fichero que queremos rebobinar.
39. MANUAL C/C++
38Henry Hernandez
FUNCIÓN FGETS:
Sintaxis:
char *fgets(char *cadena, int n, FILE *fichero);
Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o
hasta que lea un retorno de línea. En este último caso, el carácter de retorno de línea
también es leído.
El parámetro 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 leída, si se leyó con éxito, y es NULL si se
detecta elfinal del fichero o sihay un error. Los parámetros son: lacadena a leer, el número
de caracteres máximo a leer y un puntero a una estructura FILE del fichero del que se leerá.
FUNCIÓN FPUTS:
Sintaxis:
int fputs(const char *cadena, FILE *stream);
La función fputs escribe una cadena en un fichero. No se añade el carácter de retorno de
línea ni el carácter nulo final.
El valor de retorno es un número no negativo o EOF en caso de error. Los parámetros de
entrada son la cadena a escribir y un puntero a la estructura FILE del fichero donde se
realizará la escritura.
FUNCIÓN FREAD:
Sintaxis:
size_t fread(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);
Esta función 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 dirección
de memoria determinada. El usuario es responsable de asegurarse de que hay espacio
suficiente para contener la información leída.
El valor de retorno es el número de registros leídos, no el número de bytes. Los parámetros
son: un puntero a la zona de memoria donde se almacenarán los datos leídos, el tamaño de
cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del
que se hará la lectura.
40. MANUAL C/C++
39Henry Hernandez
FUNCIÓN FWRITE:
Sintaxis:
Esta función también 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 dirección de memoria determinada.
El valor de retorno es el número de registros escritos, no el número de bytes. Los
parámetros son: un puntero a la zona de memoria donde se almacenarán los datos leídos,
el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE
del fichero del que se hará la lectura.
FUNCIÓN FPRINTF:
Sintaxis:
int fprintf(FILE *fichero, const char *formato, ...);
La función fprintf funciona igual que printf en cuanto a parámetros, pero la salida se dirige
a un fichero en lugar de a la pantalla.
FUNCIÓN FSCANF:
Sintaxis:
int fscanf(FILE *fichero, const char *formato, ...);
La función fscanf funciona igual que scanf en cuanto a parámetros, pero la entrada se toma
de un fichero en lugar del teclado.
FUNCIÓN FFLUSH:
Sintaxis:
int fflush(FILE *fichero);
Esta función 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 través del buffer, y sólo cuando
el buffer se llena se realiza la escritura en el disco y se vacía el buffer. En ocasiones nos hace
falta vaciar ese buffer de un modo manual, para eso sirve ésta función.
41. MANUAL C/C++
40Henry Hernandez
El valor de retorno es cero si la función se ejecutó con éxito, y EOF si hubo algún error. El
parámetro de entrada es un puntero a la estructura FILE del fichero del que se quiere vaciar
el buffer. Si es NULL se hará el vaciado de todos los ficheros abiertos.
FUNCIÓN FSEEK:
Sintaxis:
int fseek(FILE *fichero, long int desplazamiento, int origen);
Esta función sirve para situar el cursor del fichero para leer o escribir en el lugar deseado.
El valor de retorno es cero si la función tuvo éxito, y un valor distinto de cero si hubo algún
error.
Los parámetros de entrada son: un puntero a una estructura FILE del fichero en el que
queremos cambiar el cursor de lectura/escritura, el valor del desplazamiento y el punto de
origen desde el que se calculará el desplazamiento.
El parámetro origen puede tener tres posibles valores:
SEEK_SET el desplazamiento se cuenta desde el principio del fichero. El primer byte del
fichero tiene un desplazamiento cero.
SEEK_CUR el desplazamiento se cuenta desde la posición actual del cursor.
SEEK_END el desplazamiento se cuenta desde el final del fichero.
FUNCIÓN FTELL:
Sintaxis:
long int ftell(FILE *fichero);
La función ftell sirve para averiguar la posición actual del cursor de lectura/escritura de un
fichero.
El valor de retorno será esa posición, o -1 si hay algún error.
El parámetro de entrada es un puntero a una estructura FILE del fichero del que queremos
leer la posición del cursor de lectura/escritura.
FUNCIONES:
Las funciones son un conjunto de procedimiento encapsulados en un bloque, usualmente
reciben parámetros, cuyos valores utilizan para efectuar operaciones y adicionalmente
42. MANUAL C/C++
41Henry Hernandez
retornan un valor. Esta definición proviene de la definición de función matemática la cual
posee un dominio y un rango, es decir un conjunto de valores que puede tomar y un
conjunto de valores que puede retornar luego de cualquier operación.
Complejo, en pequeños problemitas más sencillos, concentrándose en la solución por
separado, de cada uno de ellos.
En C, se conocen como funciones aquellos trozos de códigos utilizados para dividir un
programa con el objetivo que, cada bloque realice una tarea determinada.
En las funciones juegan un papel muy importe las variables, ya que como se ha dicho estas
pueden ser locales o globales.
Variables Globales: Estas se crean durante toda la ejecución del programa, y son globales,
ya que pueden ser llamadas, leídas, modificadas, etc; desde cualquier función. Se definen
antes del main().
Variables Locales: Estas, pueden ser utilizadas únicamente en la función que hayan sido
declaradas.
SINTAXIS DE UNA FUNCIÓN ES LA SIGUIENTE:
Donde:
Tipo_de_datos: Es el tipo de dato que devolverá esa función, que puede ser real, entera, o
tipo void(es decir que no devolverá ningún valor).
Nombre_de_la_funcion: Es el identificador que le damos a nuestra función, la cual debe
cumplir las reglas que definimos en un principio para los identificadores.
43. MANUAL C/C++
42Henry Hernandez
Tipo y nombre de argumentos: son los parámetros que recibe la función. Los argumentos
de una función no son más que variables locales que reciben un valor. Este valor se lo
enviamos al hacer la llamada a la función. Pueden existir funciones que no reciban
argumentos.
PASO DE PARÁMETROS
Las funciones pueden recibir datos como lo hemos observado, pero existen dos formas de
enviar los datos hacia una función por valor y por referencia, las cuales modifican en
diferente forma el comportamiento del programa.
POR VALOR
El paso por valor envía una copia de los parámetros a la función por lo tanto los cambios
que se hagan en ella no son tomados en cuenta dentro de la función main()
VARIABLES LOCALES Y GLOBALES
UNA VARIABLE LOCAL
Es aquella cuyo ámbito se restringe a la función que la ha declarado se dice entonces que la
variable es local a esa función. Esto implica que esa variable sólo va a poder ser manipulada
en dicha sección, y no se podrá hacer referencia fuera de dicha sección. Cualquier variable
que sedefina dentro de las llaves delcuerpo de una función seinterpreta como una variable
local a esa función.
UNA VARIABLE GLOBAL
Es aquella que se define fuera del cuerpo de cualquier función, normalmente al principio
del programa, después de la definición de los archivos de biblioteca (#include), de la
definición de constantes simbólicas y antes de cualquier función. El ámbito de una variable
globalson todas las funciones que componen elprograma, cualquier función puede acceder
a dichas variables para leer y escribir en ellas. Es decir, se puede hacer referencia a su
dirección de memoria en cualquier parde del programa.
