Disponible la nueva versión "donationware" 7.3 de OrganiZATOR
Descubre un nuevo concepto en el manejo de la información.
La mejor ayuda para sobrevivir en la moderna jungla de datos la tienes aquí.

Curso C++

[Home]  [Inicio]  [Índice]


3.2.6 Puntuadores

§1 Sinopsis

Los signos de puntuación del lenguaje C++ juegan el mismo papel que sus homónimos en el lenguaje natural escrito. Conocidos también como puntuadores [1], 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 ( 4.9).

[ ]  ( )  { }  ,  ;  :  ...  *  =  #  !  %  ^  &  –  +  |  ~  \  '  "  <  >  ?  .  /  

§2 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

§3 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 ( 4.2.4a)

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

§4 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++:

if (d == z) 

{

   ++x;

   func();

}


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 }

§5 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 ( 4.10.5). Es posible mezclar los dos usos (separador en lista de parámetros y operador), pero deben usarse paréntesis para distinguirlos.

§6 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 ( 4.10).  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)

}

§7 Dos puntos  :

Los dos puntos se utilizan para señalar sentencias etiquetadas ( 4.10.1):

comienzo:    x=0;    // comienzo es la etiqueta

...

goto comienzo;

§8 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 ( 4.4.1). 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 ( 1.6.2).  Ejemplo:

try {           // bloque-intento

  ...

}

catch (...) {   // captura cualquier excepción

  cout << "Se ha producido una excepción!" << endl;

  ...

}


Nota: como podéis ver, en ocasiones, mi uso particular en los ejemplos de los tres puntos, es para indicar cualquier número de sentencias. Espero que no sea motivo de confusión. Desde luego, en el caso anterior sería más correcta la notación:

try {             // bloque-intento

  // ...

}

  catch (...) {   // captura cualquier excepción

  cout << "Se ha producido una excepción!" << endl;

  // ...

}

§9 Asterisco  *

El asterisco * puede ser utilizado en C++ de tres formas: como una declaración de tipo de variable (variable de puntero 4.2 ); como operador de indirección (también llamado operador de dereferencia 4.9.11a) 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

§10 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 ( 4.9.2).  Ejemplo:

x = y;

z += 5;

§11 Almohadilla  #

Si la almohadilla # aparecen en el primer carácter (distinto de espacio en blanco) de una línea, señala directivas de preproceso (4.9.10).  En este caso, es un operador específico de la fase de preproceso del código fuente. Significa una opción del preprocesador ( 1.4) 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>

  Inicio.


[1]  Aunque se denominan también "separadores", dejaremos esta última palabra reservada para los separadores de tokens (whitespaces). A fin de evitar ambigüedades usaremos preferentemente "puntuadores" para referirnos a estos elementos.