C/Estrutura e estilo
| C | ||
| ← Volver a Directrices para o preprocesador | Estrutura e estilo | Seguir con errno → |
Este capítulo trátase dunha introdución básica de cara á produción de estruturas de código efectivas na linguaxe de programación C. Pensouse para explicar como usar de xeito efectivo as tabulacións, comentarios, e demais elementos que farán que o teu código en C sexa máis doado de ler.
Os programadores que estean a empezar probablemente non entendan a grande utilidade que supón crear estruturas no código dos seus programas, pois a miúdo pensan que o código créase simplemente para ser lido por un compilador. A miúdo isto non é certo, pois para un programador que leva meses sen traballar no código, lelo e editalo será máis doado se este está ben escrito e estruturado.
Nas vindeiras seccións, tratarase de explicar as técnicas de "boa programación" que farán os teus programas máis efectivos.
Exemplo
editarOs seguintes dous bloques de código son basicamente o mesmo: ambos os dous conteñen exactamente o mesmo código, e compilaranse e executaranse co mesmo resultado. Aínda así, hai unha diferencia esencial.
Cal dos dous pensas que é máis doado de ler?
#include <stdio.h>
int main(void) {printf("Ola mundo!\n"); return 0;}
ou
#include <stdio.h>
int main(void)
{
printf("Ola mundo!\n");
return 0;
}
O mero uso de tabulacións e saltos de liña pode mellorar e moito a facilidade de lectura do código. Ao termos un código máis lexible, é moito máis doado ver onde rematan as funcións e operacións, e que liñas son parte de que bucles e operacións.
Este libro centrarase no anterior fragmento de código, e como melloralo. Nótese que durante o transcurso do titorial, aparecerán moitos anacos de código aparentemente redundantes. Estes están simplemente para servir de exemplo de técnicas que serán explicadas, sen romper co fluxo global de código que o programa logra.
Saltos de liña e tabulacións
editarEngadir espazos en branco no teu código podería dicirse que é a parte máis importante da boa estrutura de código. O seu uso efectivo pode crear un indicador visual de como flúe o teu código, o cal pode resultar moi importante á hora de volver ao código para o seu mantemento e revisión.
Saltos de liña
editar#include <stdio.h>
int main(void){ int i=0; printf("Ola mundo!"); for (i=0; i<1; i++){ printf("\n"); break; } return 0; }
En lugar de pór todo nunha soa liña, sería moito máis lexible se se fixesen saltos de liña de xeito que cada función e cada declaración tivese a súa propia liña.
Liñas baleiras
editarAs liñas baleiras deberías de usalas en tres partes fundamentais do teu código:
- Tras declaracións de precompilación.
- Despois de declarar as novas variables.
- Entre novas rutas de código (por exemplo, declaracións de funcións ou bucles, ou tras o peche de chave "}").
#include <stdio.h>
int main(void)
{
int i=0;
printf("Ola mundo!");
for (i=0; i<1; i++)
{
printf("\n");
break;
}
return 0;
}
Seguindo as regras establecidas anteriormente, deberiamos de engadir catro liñas baleiras:
#include <stdio.h>
// Unha aquí, despois do que é unha declaración de precompilación
int main(void)
{
int i=0;
// Outra aquí, pois o bloque anterior contén declaracións de variables
printf("Ola mundo!");
// Outra máis aquí, pois a continuación empeza unha nova ruta (o bucle "for")
for (i=0; i<1; i++)
{
printf("\n");
break;
}
// E unha cuarta aquí, xa que remata a ruta anterior
return 0;
}
Isto fará o código móito máis fácil de ler que antes. Pero aínda pode ser máis lexible.
Tabulacións
editarAínda que engadir saltos de liña entre bloques de código importantes pode facer o código máis lexible, non dá unha idea do fluxo do programa. O uso do tabulador pode sermos moi útil nestes momentos: as tabulacións separan visualmente as rutas de código ao mover os puntos onde estes comezan a unha nova columna na liña. Esta práctica tan sinxela fará moito máis doado ler o código. As tabulacións seguen unha regra moi simple:
- Todo o código que estea nunha nova ruta (por exemplo, entre as dúas chaves "{" e "}") contará cunha tabulación máis que a ruta anterior.
Así que apliquémolo ao código co que estamos a traballar:
#include <stdio.h>
int main(void)
{
int i=0;
printf("Ola mundo!");
for (i=0; i<1; i++)
{
printf("\n");
break;
}
return 0;
}
Obviamente agora é perfectamente comprensible a primeira vista que rutas van dentro de cales. O uso de tabulacións pode ser moi importante.
É preciso comentar que algúns editores de texto xa automáticamente realizan as tabulacións ao premer na tecla intro.
Comentarios
editarOs comentarios poden ser moi útiles nun código para diversos propósitos. Son o modo máis doado para explicar o funcionamento e propósito de partes específicas dun programa, e mesmo supoñen unha separación visual entre varias partes do código. Comentar correctamente o teu código fará moito máis doado recordar para que servían moitas partes específicas do código.
Os comentarios en C (e noutras moitas linguaxes de programación) poden introducirse de dous xeitos:
// Comentarios dunha soa liña
ou
/*Comentarios de
máis dunha liña*/
Nótese que o uso dos comentarios dunha soa liña é relativamente recente, e podería darse o caso de compiladores que non os entendesen, máis unha versión ao día do GCC da GNU non terá ningún problema.
Este capítulo centrarase nos diversos usos de cada un deles.
Comentarios dunha soa liña
editarOs comentarios dunha soa liña son o máis útil para comentarios na marxe que expliquen o que fan certas partes do código. O mellor lugar para situar estes comentarios é a continuación das declaracións de variables, e anacos de código que poidan precisar dunha explicacións.
Partindo do noso anterior programa, haberá dous lugares idóneos para situar un comentario dunha soa liña:
#include <stdio.h>
int main(void)
{
int i=0; // Variable temporal usada para o bucle "for"
printf("Ola mundo!");
for (i=0; i<1; i++)
{
printf("\n");
break; // Saída do bucle "for"
}
return 0;
}
Comentarios de máis dunha liña
editarOs comentarios de máis dunha liña son o máis útil para grandes explicacións de código. Poden utilizarse para notas relativas aos dereitos de autor ou a licenza, e tamén para explicar o propósito de toda unha ruta de código. Isto é dobremente útil: por unha banda, facilita a comprensión das funcións, e pola outra, facilita o descubrimento de erros (se sabes o que unha ruta de código debería facer, serache máis doado atopar a parte do código culpable).
Por exemplo, poñamos que temos un programa deseñado para imprimir na pantalla "Ola mundo!" un certo número de veces, nun certo número de liñas. Habería moitos bucles for neste programa. Para este exemplo, chamaremos ao número de liñas i, e o número de cadeas por liña l.
Un bo exemplo dun comentario de máis dunha liña que di que o propósito do bucle for i é:
/* Bucle FOR (int i)
Reproduce o seguinte procedemento i veces (por número de liñas). Realiza o bucle FOR l en cada repetición,
e imprime unha nova liña ao final de cada repetición.
*/
Isto explica apropiadamente o que debe facer i, sen afondar no que fai l. Entrando en detalles respecto do que fai a ruta específica (e non unha interna), facemos máis doada a tarea de identificar erros na ruta.
De xeito similar, deberías incluír sempre un comentario de máis dunha liña ao comezo dunha función, para explicar o nome da función, os datos de entrada que vai recibir e o modo en que os vai recibir, a saída de datos, e o procedemento que debe realizar a función. Deixa sempre os detalles técnicos para rutas de código individuais dentro do programa, pois será máis doado identificar erros.
A descrición dunha función debería de ser algo semellante a isto:
/* Función : int olamundo (int i,int j)
Entrada : int i (número de liñas), int l (número de instancias por liña)
Saída : 0 (se todo vai ben)
Procedemento: Imprime "Ola mundo!" l veces, e unha nova liña de saída para i liñas.
*/
Este sistema permite unha explicación punto por punto do que debería facer a función. Podes despois entrar en detalles sobre como se archiva despois cada aspecto do programa no programa.
Para rematar, se che gustan as presentacións de calidade, este sistema de comentario de máis dunha liña, permíteche engadir bordos con asteriscos ao teu comentario. Isto fainos resaltar moito máis do que resaltarían sen o bordo (especialmente soterrados baixo unha grande cantidade de código). Debería ser algo coma:
/***************************************
* Isto ven sendo un comentario *
* de máis dunha liña rodeado por *
* un elegante bordo de asteriscos *
* que nin os de Zara. *
***************************************/
Aplicando isto ao noso programa orixinal:
#include <stdio.h>
int main(void)
{
/************************************************************************************
* Función : int main(void) *
* Entrada : ningunha *
* Saída : Devolve 0 se todo vai ben *
* Procedemento: Imprime "Ola mundo!" e unha nova liña, e logo sae. *
************************************************************************************/
int i=0; // Variable temporal usada para o bucle "for"
printf("Ola mundo!");
/* Bucle FOR (int i)
Imprime unha nova liña e sae. */
for (i=0; i<1; i++)
{
printf("\n");
break; // Saída do bucle "for"
}
return 0;
}
Isto permite a calquera usuario do programa unha forma fácil de entender o que fai o código, e como funciona. Tamén prevé confusións ocn nomes similares de funcións.
| C | ||
| ← Volver a Directrices para o preprocesador | Estrutura e estilo | Seguir con errno → |