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[editar]
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:
#include <iostream>
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[editar]
Para definir macros de preprocesador, usamos la directiva #define. La sintaxis es:
#define identificador reemplazo
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:
#undef nombre_macro
Inclusiones condicionales[editar]
Estas directivas permiten incluir o descartar partes de código, si se cumplen algunas condiciones.
- #ifdef: Permite que una seccion del programa sea compilada solo si la macro especificada como parametro ha sido definida, sin importar el valor de esta. Por ejemplo:
#ifdef TABLE_SIZE
int table[TABLE_SIZE];
#endif
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:
#ifndef TABLE_SIZE
#define TABLE_SIZE 100
#endif
int table[TABLE_SIZE];
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 programacion. Por ejemplo:
#if TABLE_SIZE>200
#undef TABLE_SIZE
#define TABLE_SIZE 200
#elif TABLE_SIZE<50
#undef TABLE_SIZE
#define TABLE_SIZE 50
#else
#undef TABLE_SIZE
#define TABLE_SIZE 100
#endif
int table[TABLE_SIZE];
En el ejemplo anterior, se muestra el uso de todas las directivas condicionales del preprocesador.
Control[editar]
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:
#line numero "nombre_de_archivo"
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:
#line 20 "asignacion de variable"
int a?;
Este código generará un error que se mostrará como un error en el archivo de "asignación de variable", línea 20.
Error[editar]
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:
#ifndefcplusplus
#error A Se requiere compilador de C++
#endif
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 los compiladores de C++).
Inclusión de fichero[editar]
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[editar]
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[editar]
En esta seccion 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:
#include <iostream>
#define PI 3.1415
std::string autor: "Wikibooks";
int adicion(int, int);
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[editar]
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:
#include <iostream>
#define PI 3.1415
std::string autor= "Wikibooks";
int adicion(int, int);
int main(int argc, char **argv)
{
std::cout<<"El resultado de la suma de 1 y 2 es "<<adicion(1,2)<<std::endl;
return 0;
}
int adicion(int a, int b)
{
return a+b;
}
Los parámetros de entrada de la función main es algo que se abordará mas adelante.
Proceso de desarrollo de un programa[editar]
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:
$emacs hola.cpp &
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
Ejemplo
// Aquí generalmente se suele indicar qué se quiere con el programa a hacer
// Programa que muestra 'Hola mundo' por pantalla y finaliza
// Aquí se sitúan todas las librerias que se vayan a usar con #include,
// que se verá posteriormente
// Las librerias del sistema son las siguientes
#include <iostream>
// Función main
// Recibe: void
// Devuelve: int
// Función principal, encargada de mostrar "Hola Mundo",por pantalla
int main(void)
{
// Este tipo de líneas de código que comienzan por '//' son comentarios
// El compilador los omite, y sirven para ayudar a otros programadores o
// a uno mismo en caso de volver a revisar el código
// Es una práctica sana poner comentarios donde se necesiten,
std::cout << "Hola Mundo" << std::endl;
// Mostrar por std::cout el mensaje Hola Mundo y comienza una nueva línea
return 0;
// se devuelve un 0.
//que en este caso quiere decir que la salida se ha efectuado con éxito.
}
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
#include <iostream>
int main(void){ std::cout << "Hola Mundo" << std::endl; return 0; }
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
Ejemplo
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf( "Hola Mundo\n" );
return EXIT_SUCCESS;
// 'EXIT_SUCCESS' es una definición que está dentro de 'stdlib.h'
// tambien funciona return 0
}
Nota: si se usa Windows, el código es el mismo, pero debemos agregar un metodo mas 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 permitira leer del teclado, por lo que el programa no finalizara, hasta que el usuario pulse enter.
Ejemplo
#include <iostream>
int main(void)
{
std::cout << "Hola Mundo" << std::endl;
std::cin.get();
//con 'std::cin.get();' lo que se hace es esperar hasta que el usuario pulse enter.
return 0;
}
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:
$ g++ hola.cpp -o hola
Para poder ver los resultados del programa en acción, se ejecuta el programa de la siguiente forma:
$./hola
Y a continuación se debe mostrar algo como lo siguiente:
Hola Mundo
No hay comentarios.:
Publicar un comentario