C Array en boucle

Au lieu de parcourir en boucle chaque élément d’un tableau, est-il possible de passer en revue uniquement les éléments ayant des affectations?

Dans l’exemple suivant, j’aimerais parcourir en boucle trois éléments au lieu de parcourir en boucle chaque élément du tableau. Quelles sont mes options? Je déteste parcourir en boucle des milliers d’éléments lorsque seule une poignée d’entre eux est atsortingbuée en fonction d’une certaine logique.

main() { int i, intArray[10000]; intArray[334] = 30; intArray[563] = 50; intArray[989] = 90; for (i = 0; i < 10000; i++) { printf("%d\n", intArray[i]); } } 

Merci d’avoir lu le post. Désolé si c’est un re-post. Je ne trouverais pas de question similaire dans le forum.

Seulement indirectement:

 #include  int main(void) { int i, intArray[10000]; int active[10000]; int n_active = 0; intArray[334] = 30; active[n_active++] = 334; intArray[563] = 50; active[n_active++] = 563; intArray[989] = 90; active[n_active++] = 989; for (i = 0; i < n_active; i++) printf("%d\n", intArray[active[i]]); return 0; } 

Ou, plus succinctement mais pas plus clairement:

 #include  int main(void) { int i, intArray[10000]; int active[10000]; int n_active = 0; intArray[active[n_active++]=334] = 30; intArray[active[n_active++]=563] = 50; intArray[active[n_active++]=989] = 90; for (i = 0; i < n_active; i++) printf("%d\n", intArray[active[i]]); return 0; } 

Ces deux programmes seront affectés s'il y a plus d'une affectation dans le même index (cet index sera stocké deux fois dans le tableau active ). Dans l’état actuel, il ne vérifie pas non plus le débordement du tableau active (mais cela ne devrait pas poser de problème; l’hypothèse est que seules quelques-unes des lignes sont remplies), et les index sont stockés dans l’ordre sont présentés - pas dans l'ordre des clés. Tous ces défauts peuvent être corrigés, mais prenez plus de code (il faudrait probablement une ou deux fonctions).

Vous pouvez faire quelque chose comme ça

 # include  int totalElements = 0; struct { int index, data; } Data[10000]; void addElement(int index, int data) { Data[totalElements].data = data; Data[totalElements++].index = index; } main() { int i; addElement(334, 30); addElement(563, 50); addElement(989, 90); for (i = 0; i < totalElements; i++) { printf("%d %d\n", Data[i].data, Data[i].index); } } 

Sortie

 30 334 50 563 90 989 

Cela souffre également des mêmes limitations mentionnées par Jonathan Leffler.

MODIFIER

 # include  int totalElements = 0; struct { int index, currentElement = 0, data[100]; } Data[10000]; void addElement(int index, int data) { int i; for (i = 0; i < totalElements; i++) { if (Data[i].index == index) { Data[i].data[Data[i].currentElement++] = data; return; } } Data[totalElements].data[Data[totalElements].currentElement++] = data; Data[totalElements++].index = index; } main() { int i, j; addElement(334, 30); addElement(334, 40); addElement(563, 50); addElement(563, 60); addElement(989, 80); addElement(989, 90); for (i = 0; i < totalElements; i++) { for (j = 0; j < Data[i].currentElement; j++) { printf("%d %d\n", Data[i].index, Data[i].data[j]); } } } 

Sortie

 334 30 334 40 563 50 563 60 989 80 989 90 

En utilisant cette idée, vous pouvez surmonter les limitations mentionnées par Jonathan Leffler.

Vous pourriez peut-être utiliser une structure de données différente, telle qu’une liste chaînée. Chaque nœud de la liste peut avoir deux valeurs int , l’une pouvant être l’index et l’autre la valeur. La liste chaînée ne contiendrait alors que les indicateurs atsortingbués (et vous pourriez aussi avoir la valeur == 0, si celle-ci est quelque peu différente de l’index normal non atsortingbué).

L’autre alternative serait d’utiliser quelque chose comme une structure de dictionnaire. Il existe probablement des implémentations de Dictionnaire pour C – je dirais cependant, si C ++ est disponible, vous devriez peut-être l’utiliser à la place (à moins que vous essayiez spécifiquement d’apprendre ou que vous soyez limité à C) – C ++ dispose de nombreux types de données immédiatement disponibles.