1 pièce(s) jointe(s)
[Linux] Tableaux VS structures
Salutations !!
J'ai essayé d'expliquer à mes élèves qu'il valait mieux utiliser des structures plutôt que des tableaux dans le cas où nous cherchions à trier des données qui sont liées entre elles de manière "logique": par exemple un tableau de scores obtenus
dans un jeu vidéo.
Il y a le nom du joueur qui est lié à son score: DAR 3000, FLA 2000,JUL 1000,JAS 5000 et DRA 4000...
Nous voudrions obtenir la liste des joueurs triée sur le score... si nous nous contentons de trier les scores antichronologiquement sans utiliser de structures nous voyons directement que les noms des joueurs ayant obtenu
ces scores ne sont plus cohérents par rapport à la situation initiale. Nous devons "rattrapper le coup" en attaquant l'autre tableau contenant les noms de la même manière que celui qui contient les scores.
Mon soucis c'est que les deux programmes, l'un utilisant les tableaux et l'autre utilisant les structures ont des "performances" similaires (j'utilise une manière de trier peu performante)... je n'arrive pas, avec cet exemple, à démontrer
que le mécanisme des structures en langage ANSI C nous permet, selon mon hypothèse, d'obtenir de meilleurs résultats que si nous utilisions un tableau pour chaque élément de la structure, mis à part au niveau du code source.
En effet, dans la version "tableau" il faut opérer "les échanges" des chaînes de caractères, chaque fois que nous avons découvert un élément plus grand dans le sous-ensemble des scores qui doivent être encore triés... dans la version
"structures", nous échangeons la structure complète en utilisant le mécanisme "de la variable temporaire"... je pensais que la fonction strcpy() était lente... pourtant les différences au niveau du temps d'exécution entre les deux
"versions" est quasiment identique...
"version tableaux"
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
// sauvegarder la valeur de tabScores[0]
tmp=tabScores[posFinale];
strcpy(strTmp,tabNoms[posFinale]);
// placer dans tabScores[0] la valeur de tabScores[idxplusgrand]
tabScores[posFinale]=tabScores[idxplusgrand];
strcpy(tabNoms[posFinale],tabNoms[idxplusgrand]);
// placer la valeur de tabScores[0] dans tabScores[idxplusgrand]
tabScores[idxplusgrand]=tmp;
strcpy(tabNoms[idxplusgrand],strTmp); |
"version structure"
Code:
1
2
3
4
5
|
struct s_Scores tmp;
tmp=NosScores[posFinale];
NosScores[posFinale]=NosScores[idxplusgrand];
NosScores[idxplusgrand]=tmp; |
Je cherche à montrer que les tableaux permettent de regrouper plusieurs variables de mêmes type sous un même nom et que les structures permettent de regrouper plusieurs variables de types différents sous un même nom également. Cependant je pensais que l'utilisation des structures avaient aussi un impact sur l'accès en mémoire des "champs", ce qui apparemment n'est pas le cas.
Les crochets des tableaux [] et le 'point' des structures indiquent tous deux un déplacement à effectuer en mémoire à partir de l'adresse de base correspondant au nom du tableau ou de la structure...
tabNoms[3]: indique qu'il faut se déplacer de 3 fois la taille du type de tabNoms à partir de l'adresse de tabNoms
et NosScores[3].strNom indique qu'il faut se déplacer de 3 fois la taille de la structure correspondant à NosScores et de se déplacer sur le champs "strNom" à partir de l'adresse de NosScores
Code:
1
2
3
4
5
6
|
struct s_Scores
{
int score;
char strNom[4];
}; |
...donc dans notre exemple, nous devons "sauter" la taille d'un "int" pour accéder au champs "strNom" en mémoire...
Ma question est la suivante: laquelle de ces deux approches aurait une performance notable à l'exécution du programme qui les utilise, moi je n'en vois pas, et du coup si le mécanisme n'offre pas de meilleures performances, quels seraient les avantages de recourir à une structure plutôt qu'à des tableaux créés pour chaque "champs" à manipuler ?
Bon, ici je n'ai utilisé que deux tableaux tabScores et tabNoms, peut-être que si nous avions ajouté des champs supplémentaires, la nécessité du recours aux structures aurait été plus flagrante.
Pièce jointe 353782
