Forum Clubic

Tableaux en langage C

Bonjour,

Mon problème consiste à renvoyer un tableau à deux dimensions créer dans mon main.
Dans cette fonction je veux rajouter des valeurs puis que ces valeurs soient sauvegardées dans le tableau et que le tableau soit réutiliser dans le main.
Voiçi un exemple de programme qui est plus explicit que mon charabia maladroit çi dessus.

#include <stdio.h>
#include <stdlib.h>

int num_perso_ordi(int *tab_ordi) //apelle du tableau définie précédemment dans le main

{

tab_ordi[0][0]=1;
tab_ordi[1][0]=2;
tab_ordi[2][0]=3;
tab_ordi[3][0]=4;
tab_ordi[4][0]=5;
printf(&quot;&#092;n.... %ld &quot;,tab_ordi[0][0]);    //affichage des différentes valeurs du tableau
printf(&quot;&#092;n %ld &quot;,tab_ordi[1][0]);
printf(&quot;&#092;n %ld &quot;,tab_ordi[2][0]);
printf(&quot;&#092;n %ld.... &quot;,tab_ordi[3][0]);

}

int main()
{
int tab_ordi[5][5]; //déclaration du tableau à 2 dimensions
num_perso_ordi(tab_ordi); //utilisation de la fonction num_perso
printf("\n… %ld ",tab_ordi[0][0]); //affichage des valeurs ajoutées dans la fonction main pour contrôle
printf("\n %ld ",tab_ordi[1][0]);
printf("\n %ld ",tab_ordi[2][0]);
printf("\n %ld… ",tab_ordi[3][0]);

}
Ayant cherché plus de 2 heures je suis légèrement désespéré donc si vous pouviez corriger ma syntaxe et m’expliquer en quoi consistait mon erreur je vous en serais reconnaisant.
Merci


#include <stdio.h>
#include <stdlib.h>

int num_perso_ordi(int **tab_ordi) //apelle du tableau définie précédemment dans le main
{
// indirection vers l'adresse mémoire du tableau
int ** curtab = &*tab_ordi;
 
  // pointe sur le premier élément   
  *curtab[0]=1;
  *curtab[1]=2;
  *curtab[2]=3;
  *curtab[3]=4;
  *curtab[4]=5;
  
  printf("affichage num_perso_ordi\n");  
  printf("\n %d ",*curtab[0]); //affichage des différentes valeurs du tableau
  printf("\n %d ",*curtab[1]);
  printf("\n %d ",*curtab[2]);
  printf("\n %d ",*curtab[3]);
  printf("\n %d ",*curtab[4]);  
  printf("\n");
}


int main()
{
//int tab_ordi[5][5]; //déclaration du tableau à 2 dimensions
int **tab_ordi;

   tab_ordi = (int**)malloc(sizeof(int));
   // une boucle est plus façile mais c'est pour bien montrer l'ordre d'alloc ...
   tab_ordi[0] = (int*)malloc(sizeof(int));
   tab_ordi[1] = (int*)malloc(sizeof(int));
   tab_ordi[2] = (int*)malloc(sizeof(int));
   tab_ordi[3] = (int*)malloc(sizeof(int));
   tab_ordi[4] = (int*)malloc(sizeof(int));            

   num_perso_ordi(tab_ordi); //utilisation de la fonction num_perso   
   printf("affichage tab_ordi\n");
   printf("\n %d ",tab_ordi[0][0]); //affichage des valeurs ajoutées dans la fonction main pour contrôle
   printf("\n %d ",tab_ordi[1][0]);
   printf("\n %d ",tab_ordi[2][0]);
   printf("\n %d ",tab_ordi[3][0]);
   printf("\n %d ",tab_ordi[4][0]);   
   printf("\n");
  
   fgetc(stdin);
  // ... et de dealloc
   free(tab_ordi[4]);
   free(tab_ordi[3]);
   free(tab_ordi[2]);
   free(tab_ordi[1]);            
   free(tab_ordi[0]);
   // ne pas oublier de désallouer le pointeur   
   free(*tab_ordi);

   return 0;
}

Merci beaucoup pour cette réponse ! :smiley:

Je voudrai juste savoir pourquoi il est nécessaire d’utiliser des malloc alors que le tableau n’est pas dynamique ?

Encore merci !

Dynamique ou pas, c’est plus efficient (plus perf que l’indexation), j’aurais pu encore optimiser mais par soucis de visibilité, je n’ai pas trop poussé le raisonnement :wink:

En quoi c’est plus performant?

ok.

Mais j’ai encore un problème ! J’ai besoin que mon tableau intègre plusieurs colonnes. Comment faire pour qu’elles soient prises en compte ?
J’ai tenté de rajouter des colonnes et d’entrer des valeurs dans des colonnes différentes mais j’ai un message d’erreur : invalid type argument of `unary *’

Merci

Travailler directement via les pointeurs sera toujours plus rapide qu’en utilisant l’index dans un tableau (cf le pipeline de ton cpu).


#include <stdio.h>
#include <stdlib.h>

int num_perso_ordi(int **tab_ordi) //apelle du tableau définie précédemment dans le main
{
// indirection vers l'adresse mémoire du tableau
int ** curtab = &*tab_ordi;
int *curcol = &*curtab[0];

  // pointe sur le premier élément   
  *curtab[0]=1;
  *curtab[1]=2;
  *curtab[2]=3;
  *curtab[3]=4;
  *curtab[4]=5;
  
  // tab_ordi[0][1] = 10
  curcol[1] = 10;
  
  printf("affichage num_perso_ordi\n");  
  printf("\n %d ",*curtab[0]); //affichage des différentes valeurs du tableau
  printf("\n %d ",*curtab[1]);
  printf("\n %d ",*curtab[2]);
  printf("\n %d ",*curtab[3]);
  printf("\n %d ",*curtab[4]);
  printf("\n");
}


int main()
{
//int tab_ordi[5][5]; //déclaration du tableau à 2 dimensions
int **tab_ordi;

   tab_ordi = (int**)malloc(sizeof(int));
   tab_ordi[0] = (int*)malloc(sizeof(int));
   tab_ordi[1] = (int*)malloc(sizeof(int));
   tab_ordi[2] = (int*)malloc(sizeof(int));
   tab_ordi[3] = (int*)malloc(sizeof(int));
   tab_ordi[4] = (int*)malloc(sizeof(int));            

   num_perso_ordi(tab_ordi); //utilisation de la fonction num_perso   
   printf("affichage tab_ordi\n");
   printf("\n %d ",tab_ordi[0][0]); //affichage des valeurs ajoutées dans la fonction main pour contrôle
   printf("\n %d ",tab_ordi[1][0]);
   printf("\n %d ",tab_ordi[2][0]);
   printf("\n %d ",tab_ordi[3][0]);
   printf("\n %d ",tab_ordi[4][0]);   
   printf("\n %d ",tab_ordi[0][1]);
   printf("\n");
  
   fgetc(stdin);
   free(tab_ordi[4]);
   free(tab_ordi[3]);
   free(tab_ordi[2]);
   free(tab_ordi[1]);            
   free(tab_ordi[0]);   
   free(*tab_ordi);

   return 0;
}

D’accord donc là on a juste 2 colonnes ? Si on en veut 5 il va falloir 3 lignes de plus avec des int *curcol2… int *curcol3 … et ainsi de suite ?

Non, suffit de refaire référence à la colonne désirée :


  // tab_ordi[0][1] = 10
  curcol[1] = 10;

  // tab_ordi[1][1] = 20  
  curcol = &*curtab[1];
  curcol[1] = 20;

Je suis désolé je ne comprends pas.
Serai-t-il possible d’avoir un exemple pour la 3e ligne de la 5e colonne ?
Merci


#include <stdio.h>
#include <stdlib.h>

int num_perso_ordi(int **tab_ordi) //apelle du tableau définie précédemment dans le main
{
// indirection vers l'adresse mémoire du tableau
int ** curtab = &*tab_ordi;
int *curcol = &*curtab[0];

  // pointe sur le premier élément   
  *curtab[0]=1;
  *curtab[1]=2;
  *curtab[2]=3;
  *curtab[3]=4;
  *curtab[4]=5;
  
  // tab_ordi[0][1] = 10
  curcol[1] = 10;

  // tab_ordi[3][5] = 20  
  curcol = &*curtab[3];
  curcol[5] = 20;
  
  printf("affichage num_perso_ordi\n");  
  printf("\n %d ",*curtab[0]); //affichage des différentes valeurs du tableau
  printf("\n %d ",*curtab[1]);
  printf("\n %d ",*curtab[2]);
  printf("\n %d ",*curtab[3]);
  printf("\n %d ",*curtab[4]);
  printf("\n");
}


int main()
{
//int tab_ordi[5][5]; //déclaration du tableau à 2 dimensions
int **tab_ordi;

   tab_ordi = (int**)malloc(sizeof(int));
   tab_ordi[0] = (int*)malloc(sizeof(int));
   tab_ordi[1] = (int*)malloc(sizeof(int));
   tab_ordi[2] = (int*)malloc(sizeof(int));
   tab_ordi[3] = (int*)malloc(sizeof(int));
   tab_ordi[4] = (int*)malloc(sizeof(int));            

   num_perso_ordi(tab_ordi); //utilisation de la fonction num_perso   
   printf("affichage tab_ordi\n");
   printf("\n %d ",tab_ordi[0][0]); //affichage des valeurs ajoutées dans la fonction main pour contrôle
   printf("\n %d ",tab_ordi[1][0]);
   printf("\n %d ",tab_ordi[2][0]);
   printf("\n %d ",tab_ordi[3][0]);
   printf("\n %d ",tab_ordi[4][0]);   
   printf("\n %d ",tab_ordi[0][1]);
   printf("\n %d ",tab_ordi[3][5]);   
   printf("\n");
  
   fgetc(stdin);
   free(tab_ordi[4]);
   free(tab_ordi[3]);
   free(tab_ordi[2]);
   free(tab_ordi[1]);            
   free(tab_ordi[0]);   
   free(*tab_ordi);

   return 0;
}

:neutre:

Ca y est j’ai compris !!!

Merci beaucoup ! Ca m’a sauvé la vie ! Merci :love: :ange:

Me revoilou avec un code plus étoffé et surtout, corrigé :ane:


#include <stdio.h>
#include <stdlib.h>

int num_perso_ordi(int **tab_ordi) //apelle du tableau définie précédemment dans le main
{
// indirection vers l'adresse mémoire du tableau
int ** curtab;
int *  curcol;

  // pointe sur le premier élément   
  curtab = &*tab_ordi;
  
  // tab_ordi[0][0]  
  curcol = &*curtab[0];
  curcol[0] = 10;
  curcol[1] = 11;
  curcol[2] = 12;
  curcol[3] = 13;
  curcol[4] = 14;

  // tab_ordi[1][0]
  curcol = &*curtab[1];
  curcol[0] = 20;
  curcol[1] = 21;
  curcol[2] = 22;
  curcol[3] = 23;
  curcol[4] = 24;

  // tab_ordi[2][0]
  curcol = &*curtab[2];
  curcol[0] = 30;
  curcol[1] = 31;
  curcol[2] = 32;
  curcol[3] = 33;
  curcol[4] = 34;
  
  // tab_ordi[3][0]  
  curcol = &*curtab[3];
  curcol[0] = 40;
  curcol[1] = 41;
  curcol[2] = 42;
  curcol[3] = 43;
  curcol[4] = 44;
  
  // tab_ordi[4][0]  
  curcol = &*curtab[4];  
  curcol[0] = 50;
  curcol[1] = 51;
  curcol[2] = 52;
  curcol[3] = 53;
  curcol[4] = 54;  

  printf("\n");
}


int main()
{
//int tab_ordi[5][5]; //déclaration du tableau à 2 dimensions
int **tab_ordi;

   tab_ordi = (int**)malloc(sizeof(int*)*5);
   tab_ordi[0] = (int*)malloc(sizeof(int)*5);
   tab_ordi[1] = (int*)malloc(sizeof(int)*5);
   tab_ordi[2] = (int*)malloc(sizeof(int)*5);
   tab_ordi[3] = (int*)malloc(sizeof(int)*5);
   tab_ordi[4] = (int*)malloc(sizeof(int)*5);            

   num_perso_ordi(tab_ordi); //utilisation de la fonction num_perso   
   printf("affichage tab_ordi\n");
   printf("\n %d ",tab_ordi[0][0]);
   printf("\n %d ",tab_ordi[0][1]);
   printf("\n %d ",tab_ordi[0][2]);
   printf("\n %d ",tab_ordi[0][3]);
   printf("\n %d ",tab_ordi[0][4]);
      
   printf("\n %d ",tab_ordi[1][0]);
   printf("\n %d ",tab_ordi[1][1]);
   printf("\n %d ",tab_ordi[1][2]);
   printf("\n %d ",tab_ordi[1][3]);
   printf("\n %d ",tab_ordi[1][4]);
               
   printf("\n %d ",tab_ordi[2][0]);
   printf("\n %d ",tab_ordi[2][1]);
   printf("\n %d ",tab_ordi[2][2]);
   printf("\n %d ",tab_ordi[2][3]);
   printf("\n %d ",tab_ordi[2][4]);
   
   printf("\n %d ",tab_ordi[3][0]);
   printf("\n %d ",tab_ordi[3][1]);
   printf("\n %d ",tab_ordi[3][2]);
   printf("\n %d ",tab_ordi[3][3]);
   printf("\n %d ",tab_ordi[3][4]);
   
   printf("\n %d ",tab_ordi[4][0]);
   printf("\n %d ",tab_ordi[4][1]);
   printf("\n %d ",tab_ordi[4][2]);
   printf("\n %d ",tab_ordi[4][3]);
   printf("\n %d ",tab_ordi[4][4]);
   
   printf("\n");
  
   fgetc(stdin);
   free(tab_ordi[4]);
   free(tab_ordi[3]);
   free(tab_ordi[2]);
   free(tab_ordi[1]);            
   free(tab_ordi[0]);   
   free(tab_ordi);

   return 0;
}

ok c’est bien pratique pour faire toute une ligne d’un seul coup mais je préfèrerai faire tout une colonne d’un seul coup ! :smiley:
Je sais je suis chiant mais ca marche déjà comme il faut donc c’est pas la peine de changer.


void num_perso_ordi_at_column(int **tab_ordi, const int col_idx)
{
// indirection vers l'adresse mémoire du tableau
int ** curtab;
int *  curcol;

  curtab = &tab_ordi[col_idx];
  curcol = &*curtab[0];
  curcol[0] = 1;
  curcol[1] = 2;
  curcol[2] = 3;
  curcol[3] = 4;
  curcol[4] = 5;  
}

int main()
{
int **tab_ordi;

   tab_ordi = (int**)malloc(sizeof(int*)*5);
   tab_ordi[0] = (int*)malloc(sizeof(int)*5);
   tab_ordi[1] = (int*)malloc(sizeof(int)*5);
   tab_ordi[2] = (int*)malloc(sizeof(int)*5);
   tab_ordi[3] = (int*)malloc(sizeof(int)*5);
   tab_ordi[4] = (int*)malloc(sizeof(int)*5);            

   num_perso_ordi_at_column(tab_ordi,2);
   printf("affichage colonne 2 de tab_ordi");
   printf("\n %d ",tab_ordi[2][0]);
   printf("\n %d ",tab_ordi[2][1]);
   printf("\n %d ",tab_ordi[2][2]);
   printf("\n %d ",tab_ordi[2][3]);
   printf("\n %d ",tab_ordi[2][4]);

   printf("\n");
  
   fgetc(stdin);
   free(tab_ordi[4]);
   free(tab_ordi[3]);
   free(tab_ordi[2]);
   free(tab_ordi[1]);            
   free(tab_ordi[0]);   
   free(tab_ordi);

   return 0;
}

PS : sont méchant sur hfr :wink:

ok c’est bien pratique aussi !

Merci pour tout!

PS : ouai c’est vrai… sont pas très gentils ! :smiley:

Salut !

J’ai un nouveau problème ! :smiley:

En fait j’ai besoin d’ajouter une valeur dans une case de mon tableau mais en faisant un scanf dans une autre fonction.
Donc je ne sais comment je peux écrire ca…

J’ai tenté de faire ca mais ca ne marche pas, la valeur que j’entre n’est pas renvoyée dans mon tableau :

Merci! :smiley:


void num_perso_ordi_column_set_at(int **tab_ordi, const int col_idx, const int idx, int value)
{
// indirection vers l'adresse mémoire du tableau
int ** curtab;
int *  curcol;

  curtab = &tab_ordi[col_idx];
  curcol = &*curtab[0];
  curcol[idx] = value;
}

int main()
{
int **tab_ordi;
int current_col, current_gamer, current_value;

   current_col = 2;
   current_gamer = 1;
   scanf("%d",&current_value);
   num_perso_ordi_column_set_at(tab_ordi, current_col, current_gamer, current_value);
   printf("tab[%d][%d] = %d ",current_col,current_gamer,tab_ordi[current_col][current_gamer]);

  [...]

}

je vois pas mais petit débat de forme, c’est pas un peu redondant de mettre &* ? ça fait un peu moins par moins.

sinon simplement un scanf("%ld",&curtabjoueur[i][1]) serait suffisant.