Signos de puntuación (Informática)
| ||||
Signos de puntuación. Conocidos también como puntuadores, son los que se citan a continuación. La mayoría de ellos tienen un doble uso y en ocasiones funcionan también como operadores
[ ] ( ) { } , ; : ... * = # ! % ^ & – + | ~ \ ' " < > ? . /
Sumario
Signos de puntuación o puntuadores
Corchetes
Los corchetes indican subíndices de matrices uni y multi dimensionales.
char ch, str[] = "Cadena de caracteres";
int mat[3][4]; // Matriz de 3 x 4
ch = str[3]; // cuarto elemento
Paréntesis
Los paréntesis sirven para agrupar expresiones; alterar la precedencia normal de los operadores y su asociatividad; aislar expresiones condicionales; indicar llamadas a funciones, y señalar los parámetros de estas. La sintaxis de C++ exige indefectiblemente el uso de paréntesis en múltiples ocasiones. En los ejemplos que siguen se muestran algunos usos.
d = c * (a + b); // modifica la precedencia normal
if (d == z) ++x; // imprescindible en la sentencia if
for (x =1; x<10; x++) // imprescindible en la sentencia for
func(); // señala llamada a función
int func(); // declara función
int (*fptr)(); // declara puntero a función
fptr = func; // asigna valor al puntero.
Observe que en el último caso, la ausencia de paréntesis equivale a &func
Se recomienda el uso de paréntesis en las macro-definiciones para evitar problemas potenciales en la expansión. Por ejemplo:
#define CUBO(x) ((x) * (x) * (x))
Llaves
Los pares de llaves { } señalan el comienzo y final de una sentencia compuesta, es decir, bloques de código (grupos de sentencias que son tratadas como una unidad). Constituyen el segundo paso (después de las sentencias) en la estructuración y compartimentación del código C++:
Un bloque es una sentencia compuesta, se trata de una sucesión (que puede estar vacía) de sentencias delimitadas por un par de corchetes { }.
Desde el punto de vista sintáctico, un bloque puede ser considerado como una sola sentencia. Juega un papel importante en el ámbito (scope) de los identificadores, puesto que un identificador declarado dentro de un bloque tiene un ámbito que comienza en el punto de la declaración y termina en el corchete final.
Sin embargo, el mismo identificador puede ser ocultado por otro del mismo nombre declarado en un bloque interior al primero.
Dentro de las posibilidades de memoria, los bloques pueden ser anidados a cualquier nivel (profundidad).
Después del corchete de cierre} no se necesita el punto y coma; de fin de sentencia
if (statement)
{...}; // punto y coma ilegal !!
else
Nota: las llaves sirven también en C++ para otros usos distintos de la pura delimitación de bloques de código. Por ejemplo, en la definición de estructuras, uniones y clases, en cuyo caso si puede ser necesaria la inclusión del punto y coma después de la llave de cierre}.
Coma
La coma como puntuador se utiliza para separar los elementos en las listas de parámetros de una función:
void func(int n, float f, char ch);
La coma se usa también como un operador en las expresiones con coma. Es posible mezclar los dos usos (separador en lista de parámetros y operador), pero deben usarse paréntesis para distinguirlos.
Punto y coma
El punto y coma; es el signo de fin de sentencia. Cualquier expresión legal C++ terminada por un punto y coma (incluyendo la expresión vacía - un punto y coma aislado-) es interpretado como una sentencia, conocidas como sentencia-expresión. La expresión se evalúa y el resultado se descarta; si no tiene efectos colaterales, C++ la ignora.
a + b; // evalúa a + b, descarta el resultado
++a; // efecto lateral en 'a', se descarta el valor ++a
; // expresión vacía = sentencia nula
El punto y coma se usa a veces para crear sentencias nulas:
for (i = 0; i < n; i++)
{
; // sentencia nula (hacer nada)
}
Dos puntos
Los dos puntos se utilizan para señalar sentencias etiquetadas
comienzo: x=0; // comienzo es la etiqueta
goto comienzo;
Puntos suspensivos
Los puntos suspensivos, también llamados elipsis, son tres puntos, seguidos y sin espacios intermedios; tienen varios usos en C++.
Se utilizan en las relaciones de argumentos formales de las funciones, cuando estas pueden aceptar un número variable de argumentos o pueden ser de tipo variable. Por ejemplo:
void func(int n, char ch,...);
Este prototipo de función declara que func está definida de modo que debe ser llamada con, al menos, dos argumentos: un int y un char. Además puede tener un cierto número de argumentos adicionales (puede omitirse la coma antes de la elipsis).
Se utiliza también para indicar que un manejador de excepciones ("handler") puede capturar una excepción de cualquier tipo.
Asterisco
El asterisco * puede ser utilizado en C++ de tres formas: como una declaración de tipo de variable (variable de puntero); como operador de indirección (también llamado operador de referencia y como operador de multiplicación.
Ejemplos:
char* char_ptr; // declara puntero a carácter
x = *int_ptr; // operador de indirección
l = 2 * 3.14 * r; // operador multiplicación
Signo igual
El signo igual = separa la declaración de variables de las listas de inicialización:
char array[5] = { 1, 2, 3, 4, 5 };
Recordemos que, al contrario que en C, donde las declaraciones no pueden estar precedidas por ningún código, deben ir al principio, en C++, las declaraciones de cualquier tipo pueden aparecer en cualquier punto del código (con algunas restricciones).
En la lista de argumentos de una función, el signo igual indica el valor por defecto para un parámetro:
int f(int i = 0) { ... } // el valor por defecto de k es cero
El signo igual es también utilizado como operador de asignación
Ejemplo:
x = y;
z += 5;
Almohadilla
Si la almohadilla # aparecen en el primer carácter (distinto de espacio en blanco) de una línea, señala directivas de preproceso. En este caso, es un operador específico de la fase de preproceso del código fuente. Significa una opción del preprocesador que no tiene porqué estar asociada necesariamente a generación de código.
Las directivas se sitúan generalmente al comienzo del programa, aunque legalmente pueden aparecer en cualquier punto.
Ejemplos de directivas de preproceso:
# (null directive)
#define NULO \0
#include <stdio.h>
