Bonjour !
En toute simplicité, je voudrais écrire une fonction en C du genre :
MODIF(TABLEAU, ligne, colonne, valeur)
sachant que j'ai défini TABLEAU à deux entrées correctement et que je l'utilise par ailleurs.
Au retour la valeur n'est pas inscrite dans la partie de programme appelante. Je m'en doutais, mais peut-on l'outrepasser ?
A la lecture du bouquin de référence du C ce n'est pas gagné (pour moi du moins).
Merci pour vos lumières !
Daniel
On trouve des chercheurs qui cherchent ; on cherche des chercheurs qui trouvent !
Bonsoir
Peut-être faudrait-il donner plus de détails, car en principe une instruction du genre de la suivante devrait suffire :
Code:TABLEAU[ligne][colonne] = valeur;
Merci PASCAL, mais en fait la fonction prévoit un autre tas de bonnes choses, et serait appelée de nombreuses fois dans le programme principal.
On trouve des chercheurs qui cherchent ; on cherche des chercheurs qui trouvent !
Salut !
Et si tu présentais ton code ?
J'ai glissé Chef !
C'est la raison pour laquelle j'ai demandé des précisions.Envoyé par danyvio
L'instruction que j'ai indiquée reste quoi qu'il en soit la façon classique de réaliser l'opération demandée en langage C.
Je vais reformuler ma demande initiale :
Comment récupérer dans le programme appelant un tableau modifié au sein d'une fonction ?
On trouve des chercheurs qui cherchent ; on cherche des chercheurs qui trouvent !
Vous ne reformulez pas, vous dites quelque chose de complètement différent.
Donc merci de préciser, car personne ici n'a de gout pour les devinettes, a priori.
"récupérer un tableau", ça veut dire quoi ? Si un tableau est défini il est accessible, il n'y rien d'autre à dire là dessus.
Soit c'est ce que renvoie ta fonction par return, soit tu as passé le tableau en argument et la fonction le modifie...
En pratique en C, c'est la même chose parce qu'on ne copie pas les tableaux avant de les passer à la fonction et celle ci n'en fait pas une copie elle même.
Quelques rappels pour comprendre la suite :
En langage C, un tableau est une suite d'éléments de base, de tailles identiques, stockés en mémoire de façon contiguë. Il est représenté par son adresse de départ en mémoire, c'est-à-dire par un pointeur.
Un tableau à plusieurs dimensions est un tableau de tableaux, de tailles identiques, stockés en mémoire de façon contiguë, ce qui constitue au final une suite d'éléments de base stockés de façon contiguë.
Ainsi, un tableau à deux dimensions TABLE[L][C] sera constitué d'une suite de L lignes, chacune constituée d'une suite de C éléments de base.
Pour atteindre l'élément TABLE[x][y] quand l'adresse de TABLE et les valeurs x et y sont données, il est également nécessaire de connaître la taille C des colonnes. En effet, l'élément TABLE[x][y] est situé à la position (x*C+y) dans la suite constituant le tableau.
La taille C des colonnes doit être une constante du programme, ou bien une valeur stockée dans une variable qui est accessible au moment où le contenu du tableau est manipulé.
Concernant le partage d'un tableau entre une fonction et le corps du programme qui l'appelle, il y a deux cas à considérer :
• soit le tableau est créé en mémoire par la fonction appelée, auquel cas celle-ci doit retourner l'adresse du tableau au programme (qui devra s'assurer que la mémoire allouée sera libérée une fois le travail terminé),
• soit le tableau existe déjà en mémoire avant l'appel de la fonction, et alors le programme connaît son adresse et doit la passer à la fonction (à moins qu'il ne s'agisse d'une variable globale, auquel cas cela n'est pas nécessaire).
Imaginons que la fonction soit destinée à calculer la table de multiplication de 1x1 à 10x10.
• Dans le premier cas, l'adresse peut être retournée normalement par la fonction :
NB : le pointeur « table » contient l'adresse de la mémoire allouée pour recevoir le contenu du tableau. Son adresse est nulle si l'allocation de mémoire a échoué (pour cause de mémoire insuffisante, par exemple).Code:int *table_multiplication() { int i, j; int *table; int *ligne; table = (int *)malloc(10*10*sizeof(int)); // alloue l'espace nécessaire en mémoire if (table) { // allocation effectuée ? for (i=0; i<10; i++) { // remplit chaque ligne de la table ligne = &table[i*10]; // pointe sur une ligne for (j=0; j<10; j++) // remplit chaque colonne de la ligne ligne[j] = (i+1)*(j+1); } } return table; // retourne l'adresse de la table }
L'adresse peut également être écrite dans un pointeur dont l'adresse est passée en argument :
NB : si l'adresse du pointeur passée à la fonction est nulle, le travail n'est pas réalisé.Code:void table_multiplication(int **ptable) { int i, j; int *table; if (ptable) { // pointeur valide ? table = (int *)malloc(10*10*sizeof(int)); // alloue l'espace nécessaire en mémoire if (table) { // allocation effectuée ? for (i=0; i<10; i++) { // remplit chaque ligne de la table ligne = &table[i*10]; // pointe sur une ligne for (j=0; j<10; j++) // remplit chaque colonne de la ligne ligne[j] = (i+1)*(j+1); } } *ptable = table; // sauve l'adresse de la table dans le pointeur } }
• Dans le deuxième cas :
ou encore, puisque la taille des colonnes du tableau est prédéterminée :Code:void table_multiplication(int *table) { int i, j; if (table) { // pointeur valide ? for (i=0; i<10; i++) { // remplit chaque ligne de la table ligne = &table[i*10]; // pointe sur une ligne for (j=0; j<10; j++) // remplit chaque colonne de la ligne ligne[j] = (i+1)*(j+1); } } }
Code:void table_multiplication(int table[][10]) { if (table) { // adresse valide ? for (i=1; i<=10; i++) { // remplit la table for (j=1; j<=10; j++) table[i][j] = (i+1)*(j+1); } } }
Oups... À trop vouloir changer d'avis dans la précipitation et ne pas se relire, on finit par écrire n'importe quoi. Les boucles for dans le dernier bout de code sont incorrectes. Il faut lire :
Et dans ce cas, je parle bien évidemment du nombre de colonnes (et donc de la taille des lignes) qui est prédéterminé.Code:void table_multiplication(int table[][10]) { if (table) { // adresse valide ? for (i=0; i<10; i++) { // remplit la table for (j=0; j<10; j++) table[i][j] = (i+1)*(j+1); } } }
Une solution élégante permettant de traiter séparément les questions de tableaux multidimensionnels et les questions d'adresses et de pointeurs consiste à définir un type C particulier correspondant au tableau utilisé.
Par exemple :
Code:#include<stdio.h> #include<stdlib.h> typedef int TAB10x10[10][10]; // définition d'un type de tableau de 10x10 entiers void table_multiplication(TAB10x10 **pptab) { int i, j; TAB10x10 *ptab; if (pptab) { // adresse du pointeur valide ? ptab = (TAB10x10 *)malloc(sizeof(TAB10x10)); // alloue l'espace pour le tableau if (ptab) { // allocation effectuée ? for(i=0; i<10; i++) // remplit le tableau for(j=0; j<10; j++) (*ptab)[i][j] = (i+1)*(j+1); } *pptab = ptab; // sauve l'adresse du tableau --> ptabmul } } int main(void) { int i, j; TAB10x10 *ptabmul = NULL; table_multiplication(&ptabmul); // créée et remplit le tableau if (ptabmul) { // création du tableau réussie ? for (i=0;i<10;i++) { // affiche le tableau for (j=0;j<10;j++) printf(" %3d", (*ptabmul)[i][j]); printf("\n"); } free(ptabmul); // libère l'espace alloué pour le tableau } printf("\n"); return 0; }
Merci PASCAL, tes exemples m'ont permis d'avancer dans mon programme, plus facilement qu'avec le bouquin de référence.
On trouve des chercheurs qui cherchent ; on cherche des chercheurs qui trouvent !
C'est la réponse exacte. Il faut donner plus de détails pour que le programme reserve la mémoire nécessaire pour en appelant la fonction
