Regla 0x0009h: Espaciado consistente en declaraciones de doble puntero (tipo **var)

0x0009h: Espaciado consistente en declaraciones de doble puntero (tipo **var)¶

Enunciado normativo¶

DEBE escribirse los asteriscos de un doble puntero unidos entre sí y adheridos al identificador (char **argv). NO DEBE separarse los asteriscos entre sí ni del nombre (char* *argv, char * * argv, char** argv).

La regla extiende la convención de 0x0005h: El asterisco de los punteros debe declararse junto al identificador a dos o más niveles de indirección.

¿Por qué existe esta regla?¶

El problema¶

Cada asterisco de una declaración de puntero forma parte del declarador (§6.7.6). Separarlos con espacios (char * * argv) hace que el lector dude de si son dos operadores distintos o parte de un mismo tipo. Pegarlos al tipo (char** argv) vuelve a crear la ilusión de un tipo atómico y contradice la convención de un solo puntero.

La forma canónica char **argv mantiene la coherencia: el tipo (char) y luego los dos asteriscos pegados al nombre, que es lo que se desreferencia.

Consecuencias de violarla¶

Fundamento en el estándar y en la cátedra¶

El estándar permite separar los tokens con cualquier cantidad de espacios (§6.4). La cátedra fija tipo **var como la única forma correcta para que los niveles de indirección se cuenten con la vista y para unificar la convención con 0x0005h: El asterisco de los punteros debe declararse junto al identificador.

Alcance y excepciones¶

Aplica a variables, parámetros, campos, retornos y typedefs con dos o más asteriscos. En punteros a función la forma canónica es tipo (*identificador)(params) (0x0012h: Validador de formato canónico en firmas de punteros a función), donde el asterisco va unido al nombre entre paréntesis. Las conversiones ((char **)p) siguen la misma convención.

Ejemplos exhaustivos¶

❌ Contraejemplo 1 — Asteriscos pegados al tipo¶

int main(int argc, char** argv)
{
    return 0;
}

Por qué falla: char** parece un tipo atómico; contradice la forma char * de un solo puntero y dificulta extenderlo a tres niveles.

❌ Contraejemplo 2 — Asteriscos separados entre sí¶

char * * argv;
int * * matriz;

Por qué falla: los espacios entre asteriscos hacen que * * se lea como dos operadores; el lector debe detenerse a contar cuántos niveles hay.

✅ Ejemplo conforme 1 — Doble puntero canónico¶

int main(int argc, char **argv)
{
    return 0;
}

Justificación: el tipo queda separado y los dos asteriscos, unidos entre sí y al nombre, se leen como un solo declarador de dos niveles.

✅ Ejemplo conforme 2 — Parámetro de salida¶

static int crear_tabla(size_t filas, size_t columnas, int ***salida)
{
    *salida = NULL;
    return 0;
}

Justificación: incluso con tres niveles la forma int ***salida mantiene los asteriscos juntos y el número de desreferencias necesarias se ve de un vistazo.

⚠️ Casos límite¶

• const intercalado: const char ** califica al dato apuntado; el const precede al tipo y no altera la regla de los asteriscos.

• Puntero a función con doble asterisco: se combina con 0x0012h: Validador de formato canónico en firmas de punteros a función; el asterisco del puntero va unido al nombre.

• argv: es el caso más común en main; conviene usarlo como ejemplo de referencia.

Cómo detectarla¶

Checklist de autocontrol¶

• ¿Los asteriscos del doble puntero están unidos entre sí?

• ¿Están adheridos al identificador?

• ¿Evité char** argv y char * * argv?

• ¿Apliqué la misma forma en parámetros y conversiones?

Reglas relacionadas¶

• 0x0005h: El asterisco de los punteros debe declararse junto al identificador — asterisco de un solo puntero junto al identificador.

• 0x0012h: Validador de formato canónico en firmas de punteros a función — formato canónico de punteros a función.

• 0x3005h: Minimizá el uso de múltiples niveles de indirección (punteros a punteros) — minimizar los niveles de indirección.

• 0x000Fh: Prohibición de múltiples espacios en blanco consecutivos dentro de una línea de código — prohibición de espacios múltiples.

• 0x3011h: Si una función recibe un puntero genérico para operaciones de solo lectura, la firma de la función debe utilizar const void* — const void * para datos genéricos de solo lectura.