COMPLEMENTO DE
LENGUAJE c++
3.1 DIRECTIVAS
Las directivas de preprocesamiento
ofrecen la capacidad de omitir condicionalmente secciones de los archivos de
código fuente, con el fin de notificar errores y advertencias, así como de
delimitar regiones características del código fuente. El término
"directivas de preprocesamiento" se utiliza por motivos de coherencia
con los lenguajes de programación C y C++. En C#, no existe un paso de
preprocesamiento individual; las directivas de preprocesamiento se procesan
como parte de la fase de análisis léxico.
Pp-directive:
Pp-declaration
pp-conditional
pp-line
pp-diagnostic
pp-region
pp-conditional
pp-line
pp-diagnostic
pp-region
A continuación se indican las
directivas de preprocesamiento disponibles:
- #define y #undef,
que permiten definir y anular respectivamente, la definición de símbolos
de compilación condicional
- #if, #elif, #else y #endif,
para omitir de forma condicional secciones de archivos de código fuente
- #line, que permite controlar los números de línea
de errores y advertencias
- #error y #warning,
que permiten emitir errores y advertencias respectivamente
- #region y #endregion,
para marcar de forma explícita secciones del código fuente
Una directiva de preprocesamiento
siempre ocupa una línea independiente del código fuente y siempre empieza por
un carácter # y un nombre de directiva de
preprocesamiento. Puede haber un espacio en blanco antes del carácter # y entre éste y el nombre de la directiva.
Una línea del código fuente que
contiene una directiva #define, #undef, #if, #elif, #else, #endif o #line puede terminar con un comentario en una
línea. Los comentarios delimitados (el estilo de comentarios /* */) no están
permitidos en las líneas de código fuente que contienen directivas de
preprocesamiento.
Las directivas de preprocesamiento no
son símbolos (tokens) y no forman parte de la gramática sintáctica de C#. No
obstante, las directivas de preprocesamiento pueden utilizarse para incluir o
excluir secuencias de símbolos y, de esta forma, pueden afectar al significado
de un programa de C#. Por ejemplo, una vez compilado, el programa:
#define A
#undef B
class C
{
#if A
void F() {}
#else
void G() {}
#endif
#if B
void H() {}
#else
void I() {}
#endif
}
produce como resultado exactamente la
misma secuencia de símbolos que el programa:
class C
{
void F() {}
void I() {}
}
Por lo tanto, aunque los dos
programas sean muy diferentes léxicamente, sintácticamente son idénticos.
3.2 Declaraciones Globales
Una declaración
introduce uno o más nombres en un programa. Las declaraciones pueden aparecer
varias veces en un programa. Por tanto, las clases, estructuras, tipos
enumerados y otros tipos definidos por el usuario se pueden declarar para cada
unidad de compilación. La restricción de esta declaración múltiple es que todas
las declaraciones deben ser idénticas. Las declaraciones también actúan como
definiciones, excepto cuando la declaración:
- Es
un prototipo de función (una declaración de función sin cuerpo de
función).
- Contiene
el especificador extern pero ningún inicializador (objetos y
variables) o cuerpo de función (funciones). Esto significa que la
definición no está necesariamente en la unidad de traducción actual y
proporciona al nombre vinculación externa.
- Es
de un miembro de datos estático en una declaración de clase.
Como los miembros de datos estáticos
de clase son variables discretas compartidas por todos los objetos de la clase,
se deben definir e inicializar fuera de la declaración de clase. (Para obtener
más información sobre las clases y miembros de clase, vea Clases).
- Es
una declaración de nombre de clase sin la siguiente definición, como class T;.
- Es
una instrucción typedef.
Estos son algunos
ejemplos de declaraciones que también son definiciones:
// Declare and define int variables i and j.
int i;
int j = 10;
// Declare enumeration suits.
enum suits { Spades = 1, Clubs, Hearts, Diamonds
};
// Declare class CheckBox.
class CheckBox : public Control
{
public:
Boolean IsChecked();
virtual
int ChangeState() = 0;
};
Algunas
declaraciones que no son definiciones son:
extern int i;
char *strchr( const char *Str, const char Target
);
Se considera que un
nombre se declara inmediatamente después de su declarador pero antes de su
inicializador (opcional).
3.3 Función Main:
Esto es muy sencillo; como hemos declarado la
función del tipo int, al llegar al final de su ejecución tendremos
que devolver un valor. Normalmente se devuelve 0 para indicar
que el programa ha finalizado correctamente, y cualquier otro valor para
indicar una ejecución anormal. Pero, si queremos ser completamente estrictos
(en algunas plataformas el significado de los valores se invierte, y 0 puede
significar que ha ocurrido un fallo de ejecución), emplearemos las macros EXIT_FAILURE y EXIT_SUCCESS.
Como su nombre bien indica, la primera devuelve una ejecución errónea, y la
segunda indica al proceso padre que todo ha ido como debería. Sus definiciones
se encuentran en stdlib.h para el lenguaje C y cstdlib.h para
C++.
int main()
{
return EXIT_SUCCESS; // El programa terminó la ejecución debidamente
}
{
return EXIT_SUCCESS; // El programa terminó la ejecución debidamente
}
int main()
{
return EXIT_FAILURE; // El programa encontró algún fallo y no pudo finalizar la ejecución correcta
}
{
return EXIT_FAILURE; // El programa encontró algún fallo y no pudo finalizar la ejecución correcta
}
int main()
{
return 5; // Valor de retorno personalizado; de esta manera podemos indicarle al proceso que invoca a nuestro programa que ha ocurrido algo determinado (por ejemplo, que no se ha llamado al programa con determinados parámetros)
}
{
return 5; // Valor de retorno personalizado; de esta manera podemos indicarle al proceso que invoca a nuestro programa que ha ocurrido algo determinado (por ejemplo, que no se ha llamado al programa con determinados parámetros)
}
Por último,
hablaremos de los parámetros de la función. Hasta ahora, la hemos definido sin
ningún tipo de parámetros, porque según el estándar esto puede hacerse
perfectamente; sin embargo, main acepta dos parámetros que se
explicarán a continuación (hay que recordar que siempre es o cero o dos parámetros,
en caso de emplear cualquier otro número el compilador dará warning o error,
dependiendo de lo quisquilloso que sea):
- Primer
parámetro: tipo int. Por costumbre se le llama argc,
diminutivo de argument count, pero se le puede llamar como se
desee. Como su propio nombre indica, contiene el número de argumentos que
se le pasan al programa. Hay que tener en cuenta que el primer argumento
de un programa siempre será el nombre de este, de tal
manera que si hacemos la siguiente ejecución
:> miprograma param1 param2
nuestro parámetro argc valdrá 3, y
por consiguiente, si llamamos al programa sin parámetros, argc equivaldrá
a 1.
- Segundo
parámetro: tipo char**. Aunque también puede especificarse
como char* argv[], lo importante es indicar que estamos
trabajando con un doble puntero a char, esto es, un vector de vectores de
caracteres, o para simplificar, un vector de cadenas. Como se ha indicado
anteriormente, el nombre más común para llamar a este parámetro es argv,
contracción de argument vector, y al principio puede resultar
un poco lioso lidiar con él, más aún si no se han usado punteros nunca.
Así que simplemente hay que recordar que estamos trabajando con un vector
de cadenas, y que cada posición (recordad, su extensión va desde 0 hasta argc-1)
guarda uno de los argumentos empleados al llamar a nuestro programa. Para
la ejecución de ejemplo del punto anterior, esta sería la traza de
nuestros parámetros:
argc = 3;
argv[0] = “miprograma”;
argv[1] = “param1”;
argv[2] = “param2”;
argv[0] = “miprograma”;
argv[1] = “param1”;
argv[2] = “param2”;
3.4Funciones definidas por el usuario
Las
funciones de usuario son, como su nombre indica, las que el propio usuario
declara, de igual manera que declara procedimientos. Las funciones nacen con el
propósito de ser subprogramas que siempre tienen que devolver algún valor.
Las dos
principales diferencias entre procedimientos y funciones son:
- Las funciones
siempre devuelven un valor al programa que las invocó.
- Para llamar a un
procedimiento se escribe su nombre en el cuerpo del programa, y si los
necesita, se incluyen los parámetros entre paréntesis. Para invocar una
función es necesario hacerlo en una expresión.
Las
funciones de usuario vienen definidas por un nombre, seguidas de dos paréntesis () entre
los que puede haber o no argumentos. Los argumentos son valores que se le pasan
a la función cuando se llama.
Un
ejemplo de una función sin argumentos:
#include
<stdio.h>
main ()
{
printf
(“\nEste mensaje lo muestra la función main ()”);
MiFuncion
();
}
/*
Definición de la función MiFuncion() */
MiFuncion
()
{
printf
(“\nEste otro lo muestra MiFuncion()”);
}
En este
ejemplo se utiliza la función MiFuncion() para mostrar en pantalla una frase.
Como se ve, MiFuncion() se invoca igual que printf() o scanf(), es decir,
simplemente se escribe el nombre de la función y los paréntesis. La definición
de MiFuncion() tiene el mismo aspecto que main(): el nombre de la
función con los paréntesis y, seguidamente, el cuerpo de la función encerrado entre
llaves.
Un
ejemplo de una función con argumentos. El programa visualiza el cuadrado de un
número entero por medio de una función que recibe dicho número como argumento.
#include
<stdio.h>
main ()
{
int num;
printf
(“\nTeclee un número entero: “);
scanf
(“%d”, &num);
cuadrado
(num);
}
/*
Definición de la función cuadrado() */
cuadrado
(int x)
{
printf
(“\nEl cuadrado de %d es %d\n”, x, x * x);
}
Comentarios
Publicar un comentario