Henry moises Hernandez Espinoza

Manual C/C++

Facilitador: Ing. Elsner B. González.

1

Manual C/C++

Índice

Estructura básica de un 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

Almacenamiento en memoria......................................................................................................15

Arreglos........................................................................................................................................16

Estructuras...................................................................................................................................18

Funciones en el interior de estructuras....................................................................................19

Inicialización de estructuras.....................................................................................................22

Arrays de estructuras...............................................................................................................23

Estructuras anidadas................................................................................................................24

Bibliotecas o librerías en C++. Declaración y uso de librerías. Include en C++.............................26

¿Qué son exactamente las librerías?........................................................................................26

Sintaxis para declarar Librerías en 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

Henry Hernandez

2

Manual C/C++

El bucle do...while....................................................................................................................34

Ficheros........................................................................................................................................35

Tipo FILE:..................................................................................................................................35

Función fopen:.........................................................................................................................35

Función fclose:.........................................................................................................................36

Tres funciones juntas (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ón es 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 ciclos y funciones..............................................................................................45

Henry Hernandez

3

Manual C/C++

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.

Henry Hernandez

4

Manual C/C++

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:

Henry Hernandez

SALIDA

5

Manual C/C++

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:

texto: que será mostrado por pantalla tal cual este escrito

Secuencias de escape: secuencias reservadas propias del lenguaje. Van precedidas por '\' y las más importantes son '\n' que introduce un salto de línea, y '\t' que introduce un tabulador.

Especificadores de formato: son ciertos caracteres precedidos del carácter tanto por ciento '%'.

A continuación se muestra 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

Henry Hernandez

6

Manual C/C++

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 el formato de los datos que se van a introducir 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 Otros caracteres no espacios, para entradas con formatoA continuación se

muestra 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

Henry Hernandez

7

Manual C/C++

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;

Henry Hernandez

SALIDA

8

Manual C/C++

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 el uso de cin, que es el único canal de entrada predefinido, tenemos que aclarar có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:

Escribir un programa que lea el nombre, la edad y el número de teléfono de un usuario y los muestre en pantalla.

Henry Hernandez

9

Manual C/C++

TIPOS DE DATOS EN C/C++

TIPOS DE DATOS C++ NUMÉRICOS ENTEROS

El tipo 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:

Tipo de Dato DescripciónNú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.

Henry Hernandez

10

Manual C/C++

Por ejemplo, las siguientes declaraciones son equivalentes:

unsigned int x; equivale a: unsigned x;

Henry Hernandez

11

Manual C/C++

Usando estos calificadores podemos tener los siguientes tipos enteros:

Tipo de Dato DescripciónNú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

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ónNúmero de bytes típico

Rango

Henry Hernandez

12

Manual C/C++

floatReal (Número en coma flotante)

4Positivos: 3.4E-38 a 3.4E38Negativos: -3.4E-38 a -3.4E38

doubleReal doble(Número en coma flotante de doble precisión)

8Positivos: 1.7E-308 a 1.7E308Negativos: -1.7E-308 a -1.7E308

long double Real doble largo 10Positivos: 3.4E-4932 a 1.1E4932Negativos: -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ónNúmero de bytes típico

Rango

bool Dato de tipo lógico 1 0, 1

TIPO CARÁCTER EXTENDIDO

Este tipo se utiliza para representar caracteres UNICODE. Utiliza 2 bytes a diferencia del tipo char que solo utiliza 1.

Tipo de Dato

DescripciónNúmero de bytes típico

Rango

wchar_t Carácter Unicode 2 0 a 65535

Henry Hernandez

13

Manual C/C++

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 a Z) 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.

Henry Hernandez

14

Manual C/C++

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, ya que 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.

Henry Hernandez

<Tipo> <lista de variables>;

15

Manual C/C++

ALMACENAMIENTO EN MEMORIA

A continuación, se muestran algunos ejemplos de declaración de variables en lenguaje C.

Ejemplo 1: La declaración de una variable para almacenar la edad de una persona se escribe:

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;

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.

Henry Hernandez

16

Manual C/C++

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.

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 oscilar entre 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:

Henry Hernandez

17

Manual C/C++

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 de datos. Y siguiendo la misma 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>,...];

El identificador de la estructura es un nombre opcional para referirse a la estructura.

Henry Hernandez

18

Manual C/C++

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

Henry Hernandez

19

Manual C/C++

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:

Henry Hernandez

20

Manual C/C++

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 si necesitamos usar constructores para asignar valores 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 se declaran y definen como las funciones que ya conocemos.

Henry Hernandez

21

Manual C/C++

Otro ejemplo:

En este ejemplo podemos ver cómo se define 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 se pueden 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:

Henry Hernandez

22

Manual C/C++

Cada nueva estructura anidada deberá inicializarse usando la pareja correspondiente de llaves "{}", tantas veces como sea necesario.

ARRAYS DE ESTRUCTURAS

La combinación de las estructuras con los arrays proporciona una potente herramienta para el almacenamiento y manipulación de datos.

Ejemplo:

Henry Hernandez

23

Manual C/C++

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.

Henry Hernandez

24

Manual C/C++

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:

Henry Hernandez

25

Manual C/C++

stDireccion DireccionAuxiliar;

BIBLIOTECAS O LIBRERÍAS EN C++. DECLARACIÓN Y USO DE LIBRERÍAS. INCLUDE EN C++

Junto con los compiladores de C y C++, se incluyen 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

Henry Hernandez

26

Manual C/C++

gran 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 necesidad de preocuparnos por cómo se hacen 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 de las 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 de flujos y sus typedefs estándar. Por ejemplo ostream.

iostream:

Henry Hernandez

27

Manual C/C++

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.

Henry Hernandez

28

Manual C/C++

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

Henry Hernandez

29

Manual C/C++

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:

Henry Hernandez

30

Manual C/C++

La estructura anterior, de realizarse con sentencias if, necesitaría cuatro 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.

Henry Hernandez

31

Manual C/C++

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:

Henry Hernandez

32

Manual C/C++

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 sentencia que ejecuta al final de cada iteració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:

Henry Hernandez

33

Manual C/C++

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 asigna un valor aleatorio a la variable definida anteriormente, y mientras esa variable no tenga el valor 25, el bucle sigue ejecutándose.

Henry Hernandez

34

Manual C/C++

. Sólo en ocasiones muy excepcionales será recomendado el uso del goto al crear 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"

Henry Hernandez

35

Manual C/C++

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);

Henry Hernandez

36

Manual C/C++

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.

Henry Hernandez

37

Manual C/C++

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 el final del fichero o si hay un error. Los parámetros son: la cadena 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.

Henry Hernandez

38

Manual C/C++

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.

Henry Hernandez

39

Manual C/C++

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

Henry Hernandez

40

Manual C/C++

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.

Henry Hernandez

41

Manual C/C++

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 se defina dentro de las llaves del cuerpo de una función se interpreta 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 global son todas las funciones que componen el programa, 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.

Henry Hernandez

42

Manual C/C++

ANEXOS EJERCICIO DE ESTRUCTURA

Henry Hernandez

43

Manual C/C++

FICHEROS

Ejer_violento1.0

Henry Hernandez

44

Manual C/C++

EJERCICIOS SWITCH CICLOS Y FUNCIONESCalculo del IR

Henry Hernandez

45

Manual C/C++

Cajero automático

Henry Hernandez