# Programación en C++/Lo más básico

| ← Introduccion | Iteraciones y decisiones → |

## Estructura de un programa

En general, los programas escritos en C++ tienen una estructura (básica) compuesta por tres secciones:
* Directivas de preprocesador
* declaraciones globales
* declaración de funciones

### Directivas de preprocesador

Los compiladores de C++ proporcionan bibliotecas de funciones, y cada biblioteca de funciones tiene asociada un archivo de definición que se denomina cabecera. Para utilizar algo de una biblioteca en un programa (por ejemplo, una función), hay que colocar al principio del programa una directiva de preprocesamiento seguida de la cabecera de la biblioteca entre signos de "menor que" y "mayor que" (<>).
A continuación se muestra un típico ejemplo de una directiva de preprocesador:
En el ejemplo anterior, la directiva invocada es include y la cabecera iostream, e indican al preprocesador que debe incluir la librería iostream a nuestro programa. Cabe señalar que todas las directivas comienzan con el símbolo numeral #. Dentro de las directivas de preprocesador se encuentran:
* Macros de preprocesador (#define y #undef)
* Inclusiones condicionales (#ifdef, #ifndef, #if, #endif, #else and #elif)
* Control (#line)
* Error (#error)
* Inclusión de fichero (#include)
* Pragma (#pragma)

#### Macros de preprocesador

Para definir macros de preprocesador, usamos la directiva #define. La sintaxis es:
Cuando el procesador encuentra esta directiva, este reemplaza todas las ocurrencias del identificador y son sustituidas por reemplazo. Cuando se requiere desactivar una macro, a partir de cierta parte del código, se utiliza la directiva #undef. La sintaxis es:

#### Inclusiones condicionales

Estas directivas permiten incluir o descartar partes de código, si se cumplen algunas condiciones.
* #ifdef: Permite que una sección del programa sea compilada solo si la macro especificada como parámetro ha sido definida, sin importar el valor de esta. Por ejemplo:
El ejemplo anterior indica que, si la macro TABLE_SIZE se encuentra definida, entonces procede a la creación de una matriz de enteros de tamaño TABLE_SIZE. Cabe señalar que el fin para esta directiva es la directiva #endif
* #ifndef: Permite realizar exactamente todo lo contrario a #ifdef. La lineas de código que se encuentren entre #ifndef y #endif, serán ejecutadas siempre y cuando la macro señalada como parámetro de #ifndef no se encuentre definida aun. Por ejemplo:
En el ejemplo anterior, se indica que si la macro TABLE_SIZE no está definida aún, entonces se define. Cabe señalar que el fin para la directiva #ifndef es, al igual que #ifdef, #endif.
* #if, #else y #elif (o else if): Estas directivas tienen el mismo significado que los comandos condicionales de cualquier lenguaje de programación. Por ejemplo:
En el ejemplo anterior, se muestra el uso de todas las directivas condicionales del preprocesador.

#### Control

Cuando compilamos un programa y un error ocurre durante el proceso de compilación, el compilador muestra un mensaje de error con las referencias al nombre del archivo donde ocurrió el error y un número de línea, por lo que es más fácil encontrar el código que genera el error. La directiva #line nos permite controlar ambas cosas, los números de línea en los archivos de código, así como el nombre del archivo que queremos que aparece cuando un error ocurre. Su formato es:
Donde número es el nuevo número de línea que se asignará a la siguiente línea de código. Los números de línea de las líneas sucesivas se incrementarán uno por uno desde este punto en adelante."nombre_de_archivo" es un parámetro opcional que permite redefinir el nombre del archivo que se mostrará. Por ejemplo:
Este código generará un error que se mostrará como un error en el archivo de "asignación de variable", línea 20.

#### Error

Esta directiva cancela la compilación cuando es encontrada, generando un error de compilación que puede ser especificado según un parámetro de un ejercicio. Por ejemplo:
En el ejemplo anterior, la compilación es cancelada si la macro __cplusplus no está definida (Esta macro es definida por defecto en todos los compiladores de C++).

#### Inclusión de fichero

Cuando el preprocesador encuentra la directiva #include, este reemplaza todas las ocurrencias de ella por el archivo o cabecera especificada. Existen dos formas de utilizar #include:
* #include <cabecera>: Es usado para incluir las cabeceras proporcionadas por defecto, por ejemplo, la librería estándar (string, iostream, etc.).
* #include "archivo" : Es usado para incluir archivos.

#### Pragma

La directiva #pragma es utilizada para especificar las distintas opciones del compilador. Estas opciones son especificadas dependiendo del compilador que se utilice. Si el compilador no permite un argumento para #pragma, esto es ignorado y no genera un error de sintaxis.

### Declaraciones globales

En esta sección se declaran todas variables y cabeceras de funciones que seran vistas de manera global, es decir, que su alcance es total en el programa. Por ejemplo:
En el ejemplo anterior, se definen (ademas de las directivas de preprocesador, vistas en la sección anterior) una variable y una función. La variable autor podrá ser utilizada por todas las funciones del programa. Mientras que la función "adicion" solo fue declarada de la forma "inline". Una función se dice declarada "inline" cuando solo se señala su nombre y sus tipos de entrada y salida. Su definición completa se reserva para mas adelante.

### Declaración de funciones

La ultima sección del programa es la declaración de funciones. La primera función que se debe declarar es la función principal o "main". La función main es la mas importante, pues es la que es invocada cuando el programa se ejecuta. Toda instrucción que no sea declarada dentro de esta, simplemente no sera considerada. A continuación de la función "main", se permite la definición completa de las funciones declaradas en la sección de declaraciones globales. En el siguiente ejemplo, mostraremos la estructura definitiva de un programa y la declaración completa de sus funciones:
Los parámetros de entrada de la función main es algo que se abordará mas adelante.

## Proceso de desarrollo de un programa

Si se desea escribir un programa en C++ se debe ejecutar como mínimo los siguientes pasos:
* Escribir con un editor de texto plano un programa sintácticamente válido o usar un entorno de desarrollo (IDE) apropiado para tal fin
* Compilar el programa y asegurarse de que no han habido errores de compilación
* Ejecutar el programa y comprobar que no hay errores de ejecución
Este último paso es el más costoso, por que en programas grandes, averiguar si hay o no un fallo prácticamente puede ser una tarea totémica.
Como ejemplo, si se desea escribir un archivo con el nombre hola.cpp y en él escribir un programa con emacs, por ejemplo, que es un programa de edición de textos, se puede, en GNU, ejecutar el siguiente comando:
Para otros sistemas operativos u otros entornos de desarrollo, no necesariamente se sigue este paso.
A continuación se escribe el siguiente código en C++: Ejemplo
Mediante simple inspección, el código parece enorme, pero el compilador lo único que leerá para la creación del programa es lo siguiente: Ejemplo
Como se puede observar, este código y el original no difieren en mucho salvo en los saltos de línea y que los comentarios, de los que se detallan posteriormente, están omitidos y tan sólo ha quedado "el esqueleto" del código legible para el compilador. Para el compilador, todo lo demás, sobra.
O este otro, que es, en parte, como el lenguaje C, en su versión C99, es: Ejemplo
Nota: si se usa Windows, el código es el mismo, pero debemos agregar un método más para que el programa se mantenga abierto y no se cierre la consola, cosa que en GNU, no es necesaria por que la consola ya esta abierta (al mandar a ejecutar).
Para esto podemos usar cin.get que nos permitirá leer del teclado, por lo que el programa no finaliza, hasta que el usuario pulse enter.
Ejemplo
Los pasos siguientes son para una compilación en GNU o sistema operativo Unix. En Windows tampoco es aplicable.
Con ctrl-x ctrl-s se guarda el archivo. Ahora para generar el ejecutable del programa se compila con g++ de la siguiente forma:
Para poder ver los resultados del programa en acción, se ejecuta el programa de la siguiente forma:
Y a continuación se debe mostrar algo como lo siguiente:

### Comentarios

Cuando se escriben programas es muy útil agregar comentarios que ayuden a explicar lo que realiza un programa. En C++ se pueden utilizar tres tipos de comentarios: al estilo C, al estilo C++ y usando preprocesador.
Los comentarios al estilo C se caracterizan por lo siguiente: comenzar el "bloque" de comentarios con /* y terminar dicho "bloque" de comentarios con */
Ej:
Si se usan este tipo de etiquetas de comentarios, hay que tener cuidado con el cierre (*/), por que el compilador puede tomar todo el texto como comentario, o cerrar antes de lo deseado.
Usando el estilo de código de C++ sólo pueden ocupar una línea como en el siguiente código:
Una buena práctica de programación es pensar que se programa a sabiendas de que otro programador, tal vez el lector mismo en un futuro, tenga que "desencriptar" qué quiso hacer ahí y por qué.
Otra posible forma de comentar código es usando el preprocesador. Esto se detalla más adelante en profundidad, por ahora la parte útil del preprocesador que interesa es la siguiente:
Este tipo de comentarios se usan rara vez. Generalmente son difíciles de localizar, incluso para programadores experimentados que trabajan en papel, y son fáciles de distinguir en casi cualquier IDE. Es recomendable indicar que se tratan de comentarios, o directamente no usarlos, salvo si son grandes cantidades de comentarios. Se verá más adelante que también puede tener otros usos.

### Utilización de la consola o terminal

En los ejemplos anteriores se utilizaron 'std::cout'. 'std::cout' es un "objeto" que permite escribir en la consola (la terminal en GNU/Unix/MacOSX), solo se puede utilizar gracias a que se ha incluido definiciones de su uso con la línea de código '#include <iostream>'.
Donde ALGO puede ser lo que sea que 'std::cout' sea capaz de mostrar por consola. Más adelante se trata más sobre ello en detalle y aclarando posibles dudas que ahora puedan surgir. También se utilizó 'std::endl', esto permite que el texto se escriba en una nueva línea.
Un ejemplo más completo sobre la escritura en consola es el siguiente. Ha de tenerse en cuenta que se han eliminado algunos comentarios superfluos del primer programa debido a que ahora se está tratando con más detalle acerca del uso de imprimir texto en la consola: Ejemplo
Se reta a compilar este código y a observar sus resultados. En este momento el lector está capacitado para escribir programas que impriman por pantalla el mensaje que se quiera.
Atención: Se hace hincapié en la posibilidad de que las palabras acentuadas no se puedan mostrar en la consola. Depende completamente del compilador que se pueda ver lo siguiente:
Con algunos compiladores, verá 'programación', pero con otros puede ver incluso 'programaci n'.

## Sintaxis

Sintaxis es la forma correcta en que se deben escribir las instrucciones para el computador en un lenguaje de programación específico. C++ hereda la sintaxis de C estándar, es decir, la mayoría de programas escritos para el C estándar pueden ser compilados en C++.

### El punto y coma

El punto y coma es uno de los símbolos más usados en C, C++; y se usa con el fin de indicar el final de una línea de instrucción. El punto y coma es de uso obligatorio.
ejemplo ´´´´´´
El punto y coma se usa también para separar contadores, condicionales e incrementadores dentro de una sentencia for
ejemplo

### Espacios y tabuladores

Usar caracteres extras de espaciado o tabuladores ( caracteres tab ) es un mecanismo que nos permite ordenar de manera más clara el código del programa que estemos escribiendo, sin embargo, el uso de estos es opcional ya que el compilador ignora la presencia de los mismos. Por ejemplo, el segundo de los ejemplos anteriores se podría escribir como:
y el compilador no pondría ningún reparo.

## Tipos primitivos

En un lenguaje de programación es indispensable poder almacenar información, para esto en C++ están disponibles los siguientes tipos que permiten almacenar información numérica de tipo entero o real:
| Nombre | Descripción | Tamaño* | Rango de valores* |
| char | Carácter o entero pequeño | 1byte | con signo: -128 to 127 sin signo: 0 a 255 |
| short int (short) | Entero corto | 2bytes | con signo: -32768 a 32767 sin signo: 0 a 65535 |
| int | Entero | 4bytes | con signo: -2147483648 a 2147483647 sin signo: 0 a 4294967295 |
| long int (long) | Entero largo | 8bytes | con signo: -2147483648 a 2147483647 sin signo: 0 a 4294967295 |
| bool | Valor booleano. Puede tomar dos valores: verdadero o falso | 1byte | true o false |
| float | Número de punto flotante | 4bytes | 3.4e +/- 38 (7 digitos) |
| double | De punto flotante de doble precisión | 8bytes | 1.7e +/- 308 (15 digitos) |
| long double | Long de punto flotante de doble precisión | 8bytes | 1.7e +/- 308 (15 digitos) |
* Los valores dependen de la arquitectura utilizada. Los mostrados son los que generalmente se encuentran en una máquina típica de arquitectura 32 bits.

#### El modificador long

El modificador long le indica al compilador que el tipo debe utilizar más bits que los normalmente utilizados por ejemplo si tenemos en una máquina de 32 bits como un Pentium de Intel, normalmente de un int ocupa 32 bits, pero si al declarar un entero le anteceden long, este entero ocupa 64 bits, el siguiente código muestra como utilizar este modificador:

#### El Modificador short

Similar al anterior, pero indica que se deben utilizar menos bits. Por ejemplo, en un computador de 32 bits, un short int ocupa 16 bits.

#### El Modificador unsigned

El modificador unsigned es utilizado únicamente con los enteros, permite utilizar todo el rango posible de valores en positivo,

#### El Modificador register

Este modificador sobre una variable le indica al compilador que la variable debe almacenarse en un registro en el compilador, que para el caso de los IA32, es un registro real de la propia CPU, y por tanto el tiempo de acceso es más rápido respecto a la memoria RAM. Hoy en día apenas se utiliza este modificador, ya que los compiladores son capaces de determinar de manera óptima la asignación de registros a variables del programa.

#### El Modificador volatile

Al contrario que el modificador registrer, volatile obliga al compilador a forzar el código resultante de manera que la variable modificada con este modificador, sea almacenada siempre en la memoria. El efecto que tiene es que cuando la variable se modifica con otro valor, dicha variable se almacena directamente en memoria y no queda localizado el valor sólo en el registro de la CPU como pasaba en el caso de register o en condiciones normales. Un uso muy común en el que se suele emplear este modificador, es para acceder a variables que están siendo utilizadas por drivers o por periféricos, ya que si no declarásemos esta propiedad, podría darse el caso que la CPU usase el valor de la variable, por lo que la caché guarda el valor, y poco después la CPU usase de nuevo dicha variable, pero como ésta está en cache, la CPU coge el valor que existe en la caché, que puede ser bien distinta al real puesto que un posible periférico puede haber modificado su valor.

#### El Modificador static

Dependiendo del entorno donde se declare la variable que la modifiquemos como static, puede significar dos cosas muy distintas:
* Si declaramos una variable static dentro del cuerpo de una función, lo que estamos indicándole al compilador es que dicha variable sea inicializada solo una vez (la primera vez que se llama a la función), y el resto de veces que se llame a la función, la variable contendrá el último valor asignado. Esta variable sólo podrá ser visible desde la función que declara dicha variable. Por ejemplo:
* Si declaramos una variable static fuera del cuerpo de una función, lo que le estamos indicando al compilador, es que dicha variable es privada para el modulo donde se implementa el código del contexto de la variable, es decir, que otro fichero objeto binario, no podrá tener acceso a dicha variable utilizando el modificador extern. Ejemplo:
Tenga en cuenta que para este último caso, usted podrá acceder a la variable y desde cualquier función que defina dentro de prueba.cpp, pero no tendrá acceso desde cualquier fichero objeto o fuente que no sea prueba.cpp

### Espacio que ocupan la variables (en máquinas x86)

El espacio en bits que ocupan en la computadora una variable de este tipo se puede ver en la siguiente tabla:
| Tipo | Número de Bits |
| char | 8 |
| short | 16 |
| int | 32 |
| long int | 64 |
| float | 32 |
| double | 64 |

#### Rango de los Tipos Primitivos

El rango que puede almacenar los tipos primitivos en C++ es muy importante, para poder saber cual es el rango de valores que puede almacenar un tipo es necesario conocer el número de bits del tipo. El caso para enteros y para flotantes es distinto. Para enteros se debe saber si el tipo es con signo o sin signo. si es sin signo el rango de valores que puede almacenar es el siguiente:
$[0,2^{Bits}-1]$
Si el tipo es con signo el rango es el siguiente
$[-2^{Bits-1},2^{Bits-1}-1]$
Para ilustrar lo anterior supongamos que tenemos un entero de 16 bits sin signo, entonces el rango de valores que puede almacenar es el siguiente:
$[0,2^{16}-1]=[0,65535]$
Para obtener el rango de un entero de 32 bits con signo se puede realizar el siguiente calculo:
$[-2^{31},2^{31}-1]=[-2147483648,2147483647]$
El caso de los números flotantes es distinto y depende en gran manera del compilador y el procesador que este utilizando. Sin embargo hoy en día la mayoría de los compiladores y los procesadores utilizan en estándar de la IEEE para representación en coma flotante. Para saber mas al respecto ver IEEE floating-point standard.

## Tipos enumerados (enum)

Los tipos enumerados son un mecanismo usado en C y C++ con el objetivo de agrupar de alguna manera constantes simbólicas. Para definir tipos enumerados se usa la palabra reservada enum.
Ejemplo 1
En el ejemplo anterior se define por medio de enum el tipo enumerado dias, en el mismo ejemplo se debe observar que dentro de la construcción se definen las constantes simbólicas: domingo, lunes, ... sabado; y que a las mismas el compilador les asignará respectivamente y por defecto los valores: 0, 1, 2, 3, 4, 5, 6. Es decir, las constantes mencionadas pueden usarse dentro del programa y este sabrá a que valor hace referencia cada una de las mismas. Por ejemplo, la instrucción: cout << domingo; desplegará 0 en la pantalla. El siguiente ejemplo muestra como usar las constantes enumeradas en un ciclo for.
En el siguiente ejemplo se define por medio de enum el tipo enumerado colores, en el mismo se debe de observar la eliminación del comportamiento por defecto ya que a la primera constante (gris) se le asigna en forma específica el valor de 7, de tal manera que la siguiente constante (grisoscuro) tendrá un valor igual a 8 y la constante amarillo será igual a 14.
Ejemplo 2

## Tipos definidos por el usuario

En muchas ocasiones descubriremos que los tipos primitivos no bastan para llevar a cabo ciertas tareas, debido a esto el lenguaje C, C++ da el soporte necesario para que el programador defina sus propios tipos. Para definir tipos se usa la palabra reservada typedef. Por ejemplo, si deseamos definir un tipo de dato llamado entero podemos usar la sintaxis:
Luego, podremos declarar variables, constantes y funciones del tipo entero. Por ejemplo,
Un uso más útil y común es el empleo de typedef para definir datos estructurados. Por ejemplo, supongamos que deseamos definir un tipo estructurado llamado persona y que contenga nombre, edad y sexo. Entonces podemos definir persona como:
Una vez que un tipo ya se ha definido, el mismo puede emplearse para declarar variables y constantes de este. Por ejemplo, con la instrucción:
se está declarando la variable hombre del tipo persona. Luego, para acceder a cada elemento de la variable hombre usaremos un mecanismo conocido como direccionamiento directo por medio del carácter de punto ( . ). Por ejemplo, la edad de hombre se debe indicar como:

## Variables y constantes

Una variable, como su nombre lo indica, es un determinado objeto cuyo valor puede cambiar durante el proceso de una tarea específica. Contrario a una variable, una constante es un determinado objeto cuyo valor no puede ser alterado durante el proceso de una tarea específica. En C, C++ para declarar variables no existe una palabra especial, es decir, las variables se declaran escribiendo el tipo seguido de uno o más identificadores o nombres de variables. Por otro lado, para declarar constantes existe la palabra reservada const, así como la directiva #define. A continuación se muestran ejemplos de declaración de variables y constantes.
| Variables | Constantes | Constantes |
| int a; | const int a = 100; | #define a 100 |
| float b; | const float b = 100; | #define b 100 |
Notas:
   A diferencia de las constantes declaradas con la palabra const los símbolos definidos con #define no ocupan espacio en la memoria del código ejecutable resultante.
   El tipo de la variable o constante puede ser cualquiera de los listados en Tipos primitivos, o bien de un tipo definido por el usuario.
Las constantes son usadas a menudo con un doble propósito, el primero es con el fin de hacer más legible el código del programa, es decir, si se tiene (por ejemplo) la constante numérica 3.1416 y esta representa al número pi, entonces podemos hacer declaraciones tales como:
o bien,
| ← Introducción | Arriba | Iteraciones y decisiones → |
c++ y java