16. Modularitat en Codelite
Objectius
- Comprendre la configuració inicial d'un projecte de CodeLite.
- Organització del codi en diferents fitxers en CodeLite.
Introducció
El concepte de modularitat es basa a dividir el codi en parts més petites que tinguin certa funcionalitat. Aquesta divisió permet, d'una banda, fer més llegible el codi i, d'altra banda, reutilitzar parts de codi en diferents aplicacions. La modularització més simple és l'ús de funcions i accions, però a mesura que necessitem treballar amb codis més grans, també es fa necessari separar aquestes accions i funcions en diferents fitxers. En aquesta unitat veurem de forma pràctica què fer en CodeLite per a aplicar aquestes estratègies de modularització.
1. Configuració inicial
Quan es crea un nou projecte a CodeLite, per exemple Modularitat, es genera una distribució d'arxius concreta dins de la carpeta del projecte. Si consultem el seu contingut des d'un terminal, veurem el següent:
total 12
-rw-r--r-- 1 uoc uoc 93 nov 17 23:56 main.c
-rw-rw-r-- 1 uoc uoc 4274 nov 17 23:56 Modularitat.project
L'arxiu principal main.c conté per defecte el programa HelloWorld.
Si compilem el programa des de CodeLite i tornem a consutar el contingut de la carpeta, veurem que s'ha creat una nova carpeta anomenada ./Debug:
total 24
drwxrwxr-x 2 uoc uoc 4096 nov 17 23:58 Debug
-rw-r--r-- 1 uoc uoc 93 nov 17 23:56 main.c
-rw-rw-r-- 1 uoc uoc 3249 nov 17 23:58 Modularitat.mk
-rw-rw-r-- 1 uoc uoc 4274 nov 17 23:56 Modularitat.project
-rw-rw-r-- 1 uoc uoc 17 nov 17 23:58 Modularitat.txt
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat$
La carpeta ./Debug conté el programa executable, juntament amb els arxius objecte intermitjos:
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat/Debug$ ls -l
total 24
-rw-rw-r-- 1 uoc uoc 4620 nov 17 23:58 main.c.o
-rw-rw-r-- 1 uoc uoc 23 nov 17 23:58 main.c.o.d
-rwxrwxr-x 1 uoc uoc 9708 nov 17 23:58 Modularitat
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat/Debug$
Si es vol, des d'un terminal es pot executar el programa Modularitat de la següent forma:
hello world
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat/Debug$
2. Múltiples arxius
A mesura que el nostre programa va creixent, es fa necessari dividir-lo en múltiples arxius. Quan tots els fitxers es troben en el mateix directori no suposa un problema, però si es troben en carpetes diferents cal indicar a CodeLite on anar a buscar-los. A continuació confirgurarem CodeLite per a organitzar i treballar amb diferents arxius en un mateix projecte.
Si continuem amb l'exemple comentat fins ara, Modularitat, el que volem és organitzar el projecte segons la següent estructura:
Es tracta de dividir (modularitzar) l'arxiu inicial main.c en tres:
- helloWorld.h : contindrà la predeclaració de totes les funcions i accions del nostre programa, així com la definició de tots els tipus necessaris (enumeratius, tuples, etc) i constants que requereixi el programa C. L'ubicarem dins de la carpeta ./include.
- helloWorld.c : en ell s'implementaran totes les accions i funcions del programa. Contindrà el codi corresponent a les predeclaracions de l'arxiu helloWorld.h.
- main.c : contindrà el codi del programa principal, identificat per la funció main().
El primer pas serà crear les carpetes ./src i ./include que necessitarà el projecte modularitzat. Ho fem des de la consola:
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat$ mkdir include
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat$ ls -l
total 36
drwxrwxr-x 2 uoc uoc 4096 nov 18 00:14 Debug
drwxrwxr-x 2 uoc uoc 4096 nov 18 00:18 include
-rw-r--r-- 1 uoc uoc 93 nov 17 23:56 main.c
-rw-rw-r-- 1 uoc uoc 3230 nov 18 00:14 Modularitat.mk
-rw-rw-r-- 1 uoc uoc 4350 nov 18 00:10 Modularitat.project
-rw-rw-r-- 1 uoc uoc 17 nov 18 00:14 Modularitat.txt
drwxrwxr-x 2 uoc uoc 4096 nov 18 00:18 src
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat$
A continuació transformem el programa HelloWorld en un programa modularitzat: per aquest motiu ens cal la definició d'algunes funcions/accions que ens permetin separar un únic arxiu en tres: un de capçalera (helloWorld.h), un d'implementació de funcions/accions (helloWorld.c) i un de principal (main.c). Per tant, l'objectiu és passar del següent programa:
[Exemple 16_01]
int main(int argc, char **argv) {
printf("hello world\n");
return 0;
}
Al següent codi modularitzat:
[Exemple 16_02]
/* Predeclaració de les funcions/accions */
void showHelloMessage();
/* Codi principal */
int main(int argc, char **argv) {
showHelloMessage();
return 0;
}
/* Implementació de les funcions/accions */
void showHelloMessage() {
printf("hello world\n");
};
Si s'executa el nou main.c, continuarà mostrant correctament el missatge "hello world". L'objectiu és acabar dividint-lo en tres blocs:
[Exemple 16_03]
/* Inici del contingut de l'arxiu helloWorld.h */
/* Predeclaració de les funcions/accions */
void showHelloMessage();
/* Fi del contingut de l'arxiu helloWorld.h */
/* Inici del contingut de l'arxiu main.c */
/* Codi principal */
int main(int argc, char **argv) {
showHelloMessage();
return 0;
}
/* Fi del contingut de l'arxiu main.c */
/* Inici del contingut de l'arxiu helloWorld.c */
/* Implementació de les funcions/accions */
void showHelloMessage() {
printf("hello world\n");
};
/* Fi del contingut de l'arxiu helloWorld.c */
El primer pas que farem serà eliminar des de CodeLite el programa actual; per tant, CodeLite -> projecte Modularitat -> src -> botó dret sobre el nom de l'arxiu main.c -> Remove -> confirmem l'esborrat -> confirmem l'esborrat de l'arxiu main.c del disc.
En aquest punt, dins del projecte Modularitat únicament hi tenim una carpeta virtual src.
Creem el programa principal main.c de la següent forma: projecte Modularitat -> botó dret sobre carpeta src -> Add New File -> seleccionem el tipus C Source File (.c) -> indiquem com a Name: main.c, i com a Location seleccionem la carpeta ./src creada abans.
Creem el segon arxiu, helloWorld.c, de la mateixa manera: projecte Modularitat -> botó dret sobre carpeta src -> Add New File -> seleccionem el tipus C Source File (.c) -> indiquem com a Name: helloWorld.c, i com a Location seleccionem la mateixa carpeta ./src anteriorment.
Creem una carpeta virtual nova dins del nostre projecte: botó dret sobre el projecte Modularitat -> New Virtual Folder -> li posem per nom include.
Per finalitzar, creem el tercer arxiu, helloWorld.h. Els passos seran: projecte Modularitat -> botó dret sobre carpeta include -> Add New File -> seleccionem el tipus Header File (.h) -> indiquem com a Name: helloWorld.h, i com a Location seleccionem la carpeta ./include que acabem de crear
En aquest punt, el nostre projecte Modularitat ja tindrà l'estructura desitjada:
Ara només cal donar contingut als tres arxius acabats de crear i que inicialment estan buits.
Comencem per l'arxiu de capçalera helloWorld.h. L'editem com ho fem habitualment a CodeLite i li copiem el següent codi:
[Exemple 16_04]
/* Predeclaració de les funcions/accions */
void showHelloMessage();
Editem l'arxiu helloWorld.c amb el seu codi corresponent:
[Exemple 16_05]
void showHelloMessage() {
printf("hello world\n");
};
I per finalitzar, fem el mateix amb l'arxiu main.c:
[Exemple 16_06]
int main(int argc, char **argv) {
showHelloMessage();
return 0;
}
En aquest punt tenim el programa modularitzat, però ens falten dues qüestions:
- Configurar CodeLite per tal que tingui present on buscar l'arxiu de capçalera .h quan hi fem referència. Ho fem de la següent forma: clic botó dret sobre Modularitat -> Settings... -> Compiler -> dins de l'opció Include Paths afegir el valor .;./include.
- Fer que els arxius estiguin enllaçats entre ells, ja que en aquests moments són independents entre sí. A l'arxiu main.c es fa referència a l'acció showHelloMessage() de la qual no sap res. El que cal és importar l'arxiu de capçalera amb un include utilitzant cometes dobles:
[Exemple 16_07]
/* Codi principal */
int main(int argc, char **argv) {
showHelloMessage();
return 0;
}
El següent pas serà afegir l'include de la llibreria stdio.h dins de l'arxiu helloWorld.c, ja que en ell utilitzem la funció printf() pròpia d'aquesta llibreria:
[Exemple 16_08]
/* Implementació de les funcions/accions */
void showHelloMessage() {
printf("hello world\n");
};
En aquest punt ja tenim el programa modularitzat i ja el podem executar correctament. L'estructura resultant és la següent:
total 4
-rw-rw-r-- 1 uoc uoc 70 nov 18 00:54 helloWorld.h
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat$ ls -l ./src
total 8
-rw-rw-r-- 1 uoc uoc 122 nov 18 01:09 helloWorld.c
-rw-rw-r-- 1 uoc uoc 113 nov 18 01:07 main.c
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat$ ls -l ./Debug/
total 20
-rwxrwxr-x 1 uoc uoc 10172 nov 18 01:09 Modularitat
-rw-rw-r-- 1 uoc uoc 4544 nov 18 01:09 src_helloWorld.c.o
-rw-rw-r-- 1 uoc uoc 43 nov 18 01:09 src_helloWorld.c.o.d
-rw-rw-r-- 1 uoc uoc 2440 nov 18 01:09 src_main.c.o
-rw-rw-r-- 1 uoc uoc 75 nov 18 01:09 src_main.c.o.d
uoc@fp:~/Documents/codelite/workspaces/Test/Modularitat$
Resum
En aquesta guia hem vist aspectes molt útils i imprescindibles per a poder desenvolupar programes en l'entorn de programació CodeLite: comprendre la configuració inicial d'un projecte i com podem organitzar-lo en diferents fitxers.