Índice global de Reglas de Estilo

Sintaxis y formato visual (0x00XX)¶

Reglas de estilo visual, espaciado, indentación, llaves y formato en C.

• 0x0001h: La claridad y prolijidad son de máxima importancia

• 0x0002h: Una declaración de variable por línea

• 0x0003h: Un espacio antes y después de cada operador binario

• 0x0004h: Cada bloque debe tener una indentación de cuatro espacios respecto a su contenedor y llaves

• 0x0005h: El asterisco de los punteros debe declararse junto al identificador

• 0x0006h: Las líneas de código no deben exceder los 79 caracteres

• 0x0007h: Las llaves deben ubicarse en líneas independientes según el estilo Allman

• 0x0008h: Alineación vertical consistente en asignaciones y declaraciones consecutivas

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

• 0x000Ah: Prohibición de espacios en blanco antes de separadores de sintaxis (; y ,)

• 0x000Bh: Prohibición de espacios en blanco alrededor de operadores de acceso a miembros (-> y .)

• 0x000Ch: Prohibición de espacios en blanco entre operadores unarios (++, --, !) y su operando

• 0x000Dh: Espacio en blanco obligatorio tras la coma separadora en listas y argumentos

• 0x000Eh: Prohibición de espacios en blanco internos inmediatamente tras ‘(’ o antes de ‘)’

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

• 0x0010h: Prohibición de llaves redundantes en inicialización de tipos escalares

• 0x0011h: Validador de espaciado estricto en sentencias de control

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

• 0x0013h: Detector de etiquetas de salto goto no alineadas al margen izquierdo

• 0x0014h: Auditor de inicialización de arreglos unidimensionales con exceso de elementos

• 0x0015h: Validador de espaciado en listas de argumentos y llamadas a funciones

• 0x0016h: Validador de espaciado en operadores unarios

• 0x0017h: Agrupá sentencias relacionadas y separá bloques lógicos

Nomenclatura e identificadores (0x01XX)¶

Reglas de nombrado de identificadores, constantes, archivos y símbolos.

• 0x0101h: Los identificadores deben ser descriptivos

• 0x0102h: Los argumentos de función y las variables locales deben usar snake_case en minúsculas

• 0x0103h: Las constantes (const o #define) deben nombrarse en MAYUSCULAS_SNAKE_CASE

• 0x0104h: Los nombres de los archivos deben usar snake_case en minúsculas (sin espacios)

• 0x0105h: Los nombres de funciones deben usar snake_case estricto en minúsculas

• 0x0106h: Las variables globales deben ser declaradas como static o usar prefijo g_

• 0x0107h: Las macros #define deben nombrarse en MAYUSCULAS_SNAKE_CASE

• 0x0108h: Prohibición de identificadores con caracteres no ASCII (acentos, ñ)

• 0x0109h: Prohibición de identificadores que colisionen con palabras clave o tipos estándar

• 0x010Ah: Prohibición de identificadores con prefijos reservados para el compilador (__ o _[A-Z])

• 0x010Bh: Proporcionalidad en longitud de identificadores según su alcance

• 0x010Ch: Auditor de identificadores reservados con doble guion bajo o guion bajo inicial

• 0x010Dh: Auditor de consistencia en nombres de constantes simbólicas

• 0x010Eh: Prescindí de identificadores genéricos con sufijo numérico o afijos (numero1, num_1, n_a, a_n)

• 0x010Fh: Prohibición de constantes numéricas mágicas en índices de arreglos

• 0x0110h: Los booleanos se nombran con prefijo interrogativo (es_, puede_, etc)

• 0x0111h: Nombrá en positivo y evitá las dobles negaciones

• 0x0112h: Usá constantes simbólicas para todo literal con significado

Comentarios, documentacion y organizacion de archivos (0x02XX)¶

Reglas de comentarios, documentación de archivos y organización del código.

• 0x0201h: Escribí comentarios que expliquen el ‘porqué’, no el ‘qué’

• 0x0202h: No dejes código comentado (dead code) en los archivos fuente

• 0x0203h: Prescindí de comentarios obvios, redundantes o vacíos

• 0x0204h: Control de longitud máxima de archivos de código (máx 500 líneas)

• 0x0205h: En archivos .c la inclusión de la cabecera propia debe figurar en primer lugar

• 0x0206h: Validador de presencia de cabecera de documentación obligatoria por archivo

Estructuras de control y flujo (0x10XX)¶

Reglas sobre condicionales, lazos, bifurcaciones y flujo de ejecuciön.

• 0x1001h: Todas las estructuras de control deben utilizar llaves

• 0x1002h: Restringí el uso de break y continue; preferí lazos con bandera de control

• 0x1003h: Utilizá el lazo for para iteraciones con rango o contador definido y while para lazos controlados por condiciones lógicas

• 0x1004h: Las condiciones complejas deben simplificarse o comentarse

• 0x1005h: Reemplazá las condiciones ambiguas basadas en la ‘veracidad’ (truthiness) del tipo de dato

• 0x1006h: No utilizar la instrucción goto

• 0x1007h: No utilizar el operador condicional (ternario) ?:

• 0x1008h: Toda instrucción switch debe incluir un caso default

• 0x1009h: Prohibición de asignaciones simples dentro de condiciones lógicas

• 0x100Ah: Prohibición de estructuras de control con cuerpo vacío (if (...);)

• 0x100Bh: No utilices comparaciones en estilo Yoda (‘CONST == variable’)

• 0x100Ch: Espaciado obligatorio alrededor de operadores ternarios (‘? :’)

• 0x100Dh: Prohibición de condiciones de parada compuestas complejas en lazos for

• 0x100Eh: Delimitación obligatoria con bloque de llaves en lazos do-while

• 0x100Fh: Prohibición de cláusula else redundante tras sentencia de retorno anticipado

• 0x1010h: Prohibición de comparaciones encadenadas no idiomáticas en C (a < b < c)

• 0x1011h: Prohibición de saltos no estructurados goto fuera del patrón canónico de liberación de recursos

• 0x1012h: Prohibición de expresiones de asignación dentro de estructuras de control

• 0x1013h: Detector de expresiones booleanas complejas sin paréntesis aclaratorios

• 0x1014h: Detector de operadores de incremento o decremento múltiples en una misma expresión

• 0x1015h: Limitá la profundidad de anidación a tres niveles

• 0x1016h: Documentá el invariante de cada lazo

• 0x1017h: Escribí condiciones afirmativas y directas

• 0x1018h: No uses variables de punto flotante como control de lazo

Funciones, contratos y modularizacion (0x20XX)¶

Reglas sobre firmas, contratos, responsabilidad única y modularización.

• 0x2001h: Las funciones deben usar cláusulas de guarda y retornos anticipados para reducir la anidación profunda

• 0x2002h: Las funciones no deben contener printf o scanf, a menos que ese sea su propósito explícito

• 0x2003h: Todas las funciones deben incluir documentación completa y estructurada

• 0x2004h: No se permite el uso de variables globales

• 0x2005h: Cada función debe tener una única responsabilidad (Principio de Responsabilidad Única)

• 0x2006h: Mantené el alcance de las variables al mínimo posible

• 0x2007h: Los valores de retorno numéricos deben definirse como constantes de preprocesador o enums

• 0x2008h: Los ejercicios deben ser resueltos mediante funciones

• 0x2009h: Los nombres de funciones y procedimientos deben usar snake_case en minúsculas

• 0x200Ah: Modularización: una función no debe exceder 4 parámetros de entrada

• 0x200Bh: Prohibición de retornar la dirección de una variable local de stack

• 0x200Ch: Cada función debe tener a lo sumo un return

• 0x200Dh: Comentarios de cierre explicativos en bloques de control extensos (> 25 líneas)

• 0x200Eh: Uso obligatorio de ‘void’ explícito en funciones sin parámetros

• 0x200Fh: Prohibición de paréntesis superfluos en sentencia return

• 0x2010h: Prohibición de reasignar o modificar parámetros recibidos por valor dentro de la función

• 0x2011h: Prohibición de asignaciones múltiples a una variable sin lectura intermedia (dead store)

• 0x2012h: Tipo de retorno obligatorio ‘int’ en la función main()

• 0x2013h: Detector de bloques else superfluos tras sentencias terminales

• 0x2014h: Cada función debe caber en una sola idea y en 25 líneas

• 0x2015h: No dupliques lógica: extraé una función

• 0x2016h: Escribí el contrato de la función antes de implementarla

• 0x2017h: Toda función recursiva debe tener un caso base explícito

• 0x2018h: Los comparadores no deben usar resta sujeta a desbordamiento

Memoria, punteros y tipos (0x30XX)¶

Reglas sobre punteros, memoria dinámica, tipos, const y TADs.

• 0x3001h: Siempre verificá la asignación exitosa de memoria dinámica

• 0x3002h: Liberá siempre la memoria dinámica y asigná NULL al puntero para mitigar punteros colgantes

• 0x3003h: No mezcles operaciones de asignación y comparación en una sola línea

• 0x3004h: Utilizá typedef para definir tipos de estructuras con el sufijo _t

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

• 0x3006h: Documentá la propiedad de los recursos al utilizar punteros

• 0x3007h: Los argumentos de tipo puntero deben ser const siempre que la función no los modifique

• 0x3008h: Los punteros nulos deben ser inicializados y comparados con NULL, no con 0

• 0x3009h: Documentá explícitamente los casos en que una función puede retornar NULL

• 0x300Ah: Utilizá cast explícito al convertir tipos de punteros

• 0x300Bh: Usá siempre sizeof en las asignaciones de memoria dinámica, prefiriendo sizeof(*ptr)

• 0x300Ch: Verificá siempre los límites de los arreglos antes de acceder a sus elementos

• 0x300Dh: Utilizá enum en lugar de ‘números mágicos’ para conjuntos de estados y valores constantes

• 0x300Eh: Documentá explícitamente el comportamiento de las funciones al manejar punteros nulos como argumentos

• 0x300Fh: Liberá la memoria en el orden inverso a su asignación

• 0x3010h: Las variables que representan tamaños o índices de arreglos deben ser de tipo size_t

• 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*

• 0x3012h: Prohibición de aritmética de punteros sobre void*

• 0x3013h: Asignación de memoria con sizeof sobre puntero en lugar del tipo apuntado

• 0x3014h: Prohibición de doble liberación de memoria (double free) sobre el mismo puntero

• 0x3015h: Reallocación segura: no sobreescribir el puntero original directamente

• 0x3016h: Orden incorrecto o sospechoso de argumentos en llamadas a memset

• 0x3017h: Orden canónico de calificadores: ‘const tipo’ en lugar de ‘tipo const’

• 0x3018h: Inicialización idiomática de agregados con {0} en lugar de memset inmediato

• 0x3019h: Prohibición de comparar punteros contra constantes numéricas distintas de NULL o cero

• 0x301Ah: Validador de uso idiomático de tipos booleanos estándar

• 0x301Bh: Prohibición de casts de tipo innecesarios o redundantes

• 0x301Ch: Detector de variables locales no inicializadas con modificador const

• 0x301Dh: Diseñá los Tipos de Datos Abstractos utilizando punteros opacos

• 0x301Eh: Asigná NULL al puntero tras liberar un recurso opaco en el ámbito del cliente

• 0x301Fh: No compares números de punto flotante con igualdad exacta

Archivos y E/S (0x40XX)¶

Reglas sobre flujos de archivo, lectura/escritura y reporte de errores.

• 0x4001h: Manejá correctamente la apertura y cierre de archivos

• 0x4002h: Validá los retornos de las operaciones de lectura y escritura de archivos

• 0x4003h: Utilizá errno, perror y strerror para reportar fallos del sistema operativo de manera precisa

• 0x4004h: Mantené la simetría de recursos al abrir y cerrar archivos en el mismo nivel de abstracción

• 0x4005h: Prescindí del uso de offsets y posiciones fijas codificadas a mano en archivos binarios sin validar sus dimensiones

• 0x4006h: Prohibición del antipatrón while (!feof(f)) para control de fin de archivo

• 0x4007h: Prohibición de rutas absolutas hardcodeadas en llamadas de archivo

• 0x4008h: Validación obligatoria del valor de retorno de fclose() en modo escritura

• 0x4009h: Prohibición de anidar llamadas a fopen() directamente dentro de funciones de E/S

• 0x400Ah: Prohibición de operar sobre flujos de archivos tras haber invocado fclose() (use-after-close)

• 0x400Bh: No uses fflush(stdin); consumí el buffer con getchar()

• 0x400Ch: Los formatos de printf/scanf deben coincidir y no ser variables

Compilacion, preprocesador y seguridad (0x50XX)¶

Reglas sobre compilación, preprocesador, cabeceras y seguridad estática.

• 0x5001h: Los arreglos estáticos deben ser creados con un tamaño fijo en tiempo de compilación

• 0x5002h: Desarrollá y compilá siempre con todas las advertencias del compilador activadas

• 0x5003h: Utilizá guardas de inclusión en todos los archivos de cabecera

• 0x5004h: Todas las operaciones con cadenas deben ser seguras

• 0x5005h: Organizá la estructura de tus archivos .c de forma estándar

• 0x5006h: Preferí fgets sobre gets y scanf para leer cadenas

• 0x5007h: Inclusiones redundantes o duplicadas de la misma cabecera #include

• 0x5008h: Prohibición de funciones obsoletas o inseguras (gets, atoi)

• 0x5009h: Prohibición de división entera no intencional asignada a flotantes

• 0x500Ah: Protección obligatoria de parámetros en macros funcionales mediante paréntesis

• 0x500Bh: Inclusión obligatoria de cabeceras estándar para funciones de la biblioteca C

• 0x500Ch: Prohibición de inclusión directa de archivos de código fuente C (.c)

• 0x500Dh: Prohibición de redefinir palabras clave o tipos primitivos de C con #define

• 0x500Eh: Prohibición de la biblioteca obsoleta y no estándar <conio.h> (getch, clrscr)

• 0x500Fh: Colisión de nombres de macroguardas entre archivos de cabecera distintos

• 0x5010h: Prohibición de directivas #pragma no estándar o privativas

• 0x5011h: Prohibición de declaraciones extern en archivos de implementación (.c)

• 0x5012h: Detección de inclusiones cíclicas entre archivos de cabecera

• 0x5013h: Protección obligatoria con paréntesis envolventes en expresiones de macroconstantes (#define)

• 0x5014h: Inclusión explícita obligatoria de cabeceras para funciones de biblioteca estándar

• 0x5015h: No invoques el intérprete de comandos con system() o popen()

Proceso, diseno y construccion sistematica (0x60XX)¶

Reglas de método: como diseñar y construir código de calidad paso a paso.

• 0x6001h: Diseñá el algoritmo antes de escribir código en C

• 0x6002h: Compilá con frecuencia y resolvé el primer error antes de continuar

• 0x6003h: Declará cada variable lo más cerca posible de su primer uso

• 0x6004h: No reutilices una variable para propósitos distintos

• 0x6005h: No optimices prematuramente

Robustez y manejo de errores (0x70XX)¶

Reglas de robustez, validación e inicialización defensiva.

• 0x7001h: Siempre debés inicializar las variables a un valor conocido

• 0x7002h: Validá los datos en la frontera del programa

• 0x7003h: No ignores valores de retorno que pueden indicar fallo

• 0x7004h: No llamés exit() en funciones de biblioteca: propagá el error

• 0x7005h: Inicializá todos los campos de estructuras y arreglos

• 0x7006h: Probá explícitamente los casos borde

• 0x7007h: Evitá los parámetros bandera de tipo bool

Verificacion, testing y depuracion (0x80XX)¶

Reglas de verificacion, testing y depuracion antes de la entrega.

• 0x8001h: Una aserción por cada función de prueba

• 0x8002h: Escribí al menos una prueba por cláusula del contrato

• 0x8003h: Verificá con gcc, gdb y valgrind antes de entregar

• 0x8004h: Ejecutá la lista de verificación de calidad antes de entregar