Tableaux à diverses dimensions avec diverses taille

Question

Bonjour,je veux créer non pas un tableau multidimensionnel mais un tableau du genre:

T=[[1,2,3],[4,1],[1,6,9,0,1]]
T est un tableau composé de 3 sous-tableaux avec chacun leur dimensions
le 1er sous tableau est de taille 3,le 2ieme est de taille 2 et le 3ieme de taille 5

Comment m'y prendre,créer un type qui permet de manipuler un tel type de tableau

Ensuite ,j'aimerais créer une fonction qui ajoute un sous-tableau dans T,une autre qui permet de supprimer un sous-tableau...

leoliom · Answer

Bonjour je me suis dit que typedef c'etait pas nécessaire vu que je voulais pas renommer mon type.Mais maintenant je vois pourquoi a chaque fois on met typedef ok

En fait les T,T1 c'etait juste des exemples pour vous dire que je veux que T soit de type tableau et T1 de type mon_tableau

D'accord je vais donner le but de l'exercice
En fait mon exercice me donne T=[1,2,3,-1,4,8,9,-1,6,1,4,-1]
On me demande de transforme T de sorte à avoir T'=[[1,2,3],[4,8,9],[6,1,4]]
Donc on tient pas compte des -1
Pour pouvoir y parvenir je me suis dis qu'il faut que j'ai un type tableau(unidimensionnel comme T),un type mon_tableau(comme celui de T' de l'exo)
Je me suis dit qu'il faut aussi que je crée une fonction creer un tableau vide et ajoute un sous tableau à la fin un tableau du même type que le tableau T' de mon exo

l'algorithme que j'ai en tête en me basant sur le tableau donné dans mon exo est le suivant:

transforme(tableau T)
      Pour i allant de 0 à T.taille-1
         Trouver les indices où se trouve -1
     
         
          mon_tableau[0]->taille=4( 1er indice ou se trouve le -1)
          //Aprés ca on remet le compteur de -1 à 0
          //De base je voulais faire créer un tableau T' du type mon_tableau
         //Créer un tableau du type tableau(unidimensionnel avec 1,2,3)=>T1=[1,2,3]
          //Ensuite faire appel a ma fonction ajout pour ajouter T1 dans T'=>T'=[[1,2,3]]
            //Mais je vois qu'on pouvait faire autrement comme ce que vous avez proposé
          mon_tableau[0]->tab[0]=1
          mon_tableau[0]->tab[1]=2
          mon_tableau[0]->tab[3]=3


          //On compte les éléments avant le trouver le second -1
          mon_tableau[1]->taille=3
          mon_tableau[1]->tab[0]=4
          mon_tableau[1]->tab[1]=8
          mon_tableau[1]->tab[3]=9


         //Idem
          mon_tableau[2]->taille=3
          mon_tableau[2]->tab[0]=6
          mon_tableau[2]->tab[1]=1
          mon_tableau[2]->tab[3]=4

leoliom · Answer

En fait mon exo c'est 2 partie

1er partie:tableau composé de sous tableau de taille différente

2ieme partie:tableau composé de sous tableau de même taille


les lignes et colonnes de votre code ca veut dire on a combien de sous-tableau
3 ligne et 4 colonnes veut dire 3 sous tableau avec dedans chacun 4 éléments?

leoliom · Answer

int (*arr)[col] = calloc(row, sizeof *arr);
Le crochet [col] est censé faire quoi
C'est quoi cette notation [][],j'en avais jamais vu encore

leoliom · Answer

Oui c’est plus clair 
Mais j’ai essayé d’utiliser votre code pour répondre à la question partie 1 de mon exo(taille sous tableau différente) mais j’arrive pas ,le compilateur me renvoie que des erreurs

Esceque l’algorithme que j’ai mis tout à l’heure à 12h15 est correct?

leoliom · Answer

Non j’ai dit que la partie 1 de mon exo les sous tableaux ont des tailles différentes et pouf la partie 2 la taille
Pour l’instant,je préfère qu’on traite d’abord la partie 1 de mon exo

Non votre code marche,je voulais dire que si j’essaye de l’adapter à ma façon de sorte qu’il fasse ce que j’attend ca marche pas 

Je vais essayer de voir ce qui cloche dans mon algo et code et après plus tard je posterais ce que j’ai fait

Theo_0055 · Answer

Bonjour j'ai écrit une fonctionne qui ne retourne qu'une erreur,a savoir le return mon_tableau
mon_tableau est un pointeur or moi je veux renvoyer un type TABLEAU mais ca marche pas et je vois pas comment faire.Comment faire pour que le pointeur mon_tableau soit du type TABLEAU

#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
typedef struct tableau {
    int taille;
    int *tab;
}tableau;


typedef struct tableau TABLEAU TABLEAU;

int compte_moins_1(tableau T){
  int nb=0;
  int i;
  for(i=0;i<T.taille;i++){
    if(T.tab[i]==-1)
      nb++;
  }
  return nb;
}

TABLEAU transforme(tableau T){
    int nb_de_sous_tableaux=compte_moins_1(T) ;
    TABLEAU struct tableau ** mon_tableau = malloc(sizeof(struct tableau *) * nb_de_sous_tableaux);
    int i,compteur;
    
    bool debut_moins1=true;
    for(i=0;i<T.taille;i++){
        if(T.tab[i]!=-1){
            if(debut_moins1){
                if (i>=1){
                    int j;
                    for (j= 0; i < nb_de_sous_tableaux; i++) {
                        mon_tableau[i] = malloc(sizeof(struct tableau));
                    }
                    int k,l;
                    for(k=0;k < nb_de_sous_tableaux;k++){
                        for(l=0;l < nb_de_sous_tableaux;k++){
                            mon_tableau[k]->taille = compteur;
                            mon_tableau[k]->tab = malloc(sizeof(int) * compteur);
                            mon_tableau[k]->tab[l] = T.tab[i];
                        }
                    }
                    
                    
                }
                compteur=1;
                  
                debut_moins1=false;
            }
            else{
                int k,l;
               for(k=0;k < nb_de_sous_tableaux;k++){
                    for(l=0;l < nb_de_sous_tableaux;k++){
                        mon_tableau[k]->taille = compteur;
                        mon_tableau[k]->tab = malloc(sizeof(int) * compteur);
                        mon_tableau[k]->tab[l] = T.tab[i];
                    }
                }
              compteur+=1;
            }
        }
        else
            debut_moins1=true;
    }
    return mon_tableau;
}

Theo_0055 · Answer

TABLEAU struct tableau ** mon_tableau = malloc(sizeof(struct tableau *) * nb_de_sous_tableaux);

Ceci renvoie une erreur

Theo_0055 · Answer

Pour le 1 et 2 j'ai compris et je vois ce que vous voulez dire/

Pour le 3. En fait je veux définir un type TABLEAU .Ce type sera composé de tableau de type tableau
Esce que vous voyez ce que je eux dire?
TABLEAU c'est comme un énorme tableau et dans ce tableau il ya dedans des tableaux(sous_tableau) de tailles différentes)

A un moment j'avais pensé a faire

typedef struct TABLEAU TABLEAU{
      tableau *tab
      int taille;
}

Mais le problème c'est que si je fais ca je pourrais pas utiliser le double pointeur mon_tableau et je pourrais pas faire les mêmes opérations de ce dernier

Theo_0055 · Answer

desolé j'avais oublie de mettre l e typedef

leoliom · Answer

En fait vous,vous avez défini un type double pointeur sur un tableau appelé TABLEAU 

Le problème c’est que si je fais return mon_tableau dans la fonction que j’ai écris tout à l’heure ça me renvoie un pointeur et moi je peux pas ça mais je veux qu’il me renvoie un tableau multidimensionnel avec des sous tableaux de tailles différentes 

En fait je veux que dans mon main il y ait ceci :

Etc
tableau t=[1,2,3,-1,4,5,6,7,8,-1,4,2,-1]
TABLEAU T=transforme(t);
afficher_tableau(T);

Et je veux que ma console me renvoie 
[[1,2,3],[4,5,6,7,8],[4,2]]

A peu près c’est ça que je cherche à faire

Theo_0055 · Answer

Je pense qu'il faut que je sache manipuler correctement d'abord des tableaux simples avant de faire les tableaux un peu plus compliqué 

Pour les tableau simple j'ai fait ceci et ca a l'air de marcher

#include <stdio.h>
typedef struct tableau {
    int taille;
    int *tab;
}tableau;

tableau creer_tab_vide(){
    tableau t;
 t.taille = 0;
 t.tab = malloc(9* sizeof(int));
 return t;

}

tableau ajouter_entier(tableau t,int n){
    t.taille=t.taille+1;
    int dernier_indice=t.taille-1;
    
    t.tab[dernier_indice]=n;
    return t;
    
}

tableau creer_tab_vide(){
    tableau t;
 t.taille = 0;
 t.tab = malloc(9* sizeof(int));
 return t;

}

tableau ajouter_entier(tableau t,int n){
    t.taille=t.taille+1;
    int dernier_indice=t.taille-1;
    
    t.tab[dernier_indice]=n;
    return t;
    
}

int main(void){
    tableau t;
    t=creer_tab_vide();
    t=ajouter_entier(t,1);
    t=ajouter_entier(t,2);
    t=ajouter_entier(t,3);
    t=ajouter_entier(t,4);
    t=ajouter_entier(t,-1);
    t=ajouter_entier(t,6);
    t=ajouter_entier(t,7);
    t=ajouter_entier(t,8);
    t=ajouter_entier(t,-1);
    afficher_tableau(t);
   return 0;
}

Seul bémol dans creer tableau vide j'ai mis le nombre 9 car je sais que dans le main mon tableau est de taille 9
Comment faire pour connaitre d'avance le nombre d'espace qu'on doit stocker
ou sinon si on veut ajouter un entier,je veux que la taille augmente de 1 pour mettre l'entier(reservation dynamique)



Une fois que j'aurais compris le fonctionnement des tableaux simples,je pourrais revenir a mon exo et appliquer vos conseils

leoliom · Answer

Non c'est mon 2ieme compte que j'utilise pas beaucoup,ah j'ai écris mon message avec ce compte sans faire exprès désolé
Mon vrai compte est leoliom


Pour résoudre ce problème,j'ai modifié le code en faisant

typedef struct tableau {
    int taille;
    int *tab;
    int T_MAX;
}tableau;

tableau creer_tab_vide(){
    tableau t;
 t.taille = 0;
 t.T_MAX=10;
 t.tab = malloc(9* sizeof(int));
 return t;

}

tableau ajouter_entier(tableau t,int n){
    if( t.taille==t.T_MAX)
         t.tab=realloc(t.tab,2*sizeof(int));
    t.taille=t.taille+1;
    int dernier_indice=t.taille-1;
    
    t.tab[dernier_indice]=n;
    return t;
    
}

Mais bizarrement à un moment il y a un nombre bizarre



Ai-je mal uttilisé realloc pourtant j'ai lu le site que vous m'avez donné

leoliom · Answer

finalement c'est bon probleme résolu j'ai modifié 
t.tab=realloc(t.tab,2*t.T_MAX*sizeof(int));

leoliom · Answer

Maintenant je vais essayer d'appliquer le même principe sur tableaux avec des sous_tableau et je reviens plus tard

Aussi esceque la methode de réallocation que j'ai utilisé est compliqué,y avait il plus simple?

leoliom · Answer

Voici ce que j'ai fait pour éviter les fuites mémoires

temp = realloc (tabentier, 4 * sizeof(int) );

tableau ajouter_entier(tableau t,int n){
    int * temp;
    if( t.taille==t.T_MAX){
         temp=realloc(t.tab,2*sizeof(int));
         if ( temp == NULL ){
              printf("Reallocation impossible");
              free(t);
          }
    }

t.taille=t.taille+1;
    int dernier_indice=t.taille-1;
    
    t.tab[dernier_indice]=n;
    return t;
    
}

leoliom · Answer

Si j'ai lu lma doc mais l'exemple je l'ai pas compris du coup j'ai regardé sur ce site mlà:https://rperrot.developpez.com/articles/c/allocationC/   au niveau du 2)Là il explique bien mieux les choses et j'ai appliqué le même principe mais apparemment c'est pas comme ca




Bref merci pour votre aide,je vais regardé plus de vidéo sur le C pour mieux comprendre
les choses

Merci d'avoir été patient avec moi

leoliom · Answer

je veux pas vous fatigué ce sera ma dernière question et j'essayerais de faire le reste moi meme

#include <stdlib.h>

struct tableau {
    int taille;
    int *tab;
};

int main(void) {
        int nb_de_sous_tableaux = 3;

        struct tableau ** mon_tableau = malloc(sizeof(struct tableau *) * nb_de_sous_tableaux);
        for (int i = 0; i < nb_de_sous_tableaux; i++) {
                mon_tableau[i] = malloc(sizeof(struct tableau));
        }

        mon_tableau[0]->taille = 3;
        mon_tableau[0]->tab = malloc(sizeof(int) * 3);
        mon_tableau[0]->tab[0] = 1;
        mon_tableau[0]->tab[1] = 2;
        mon_tableau[0]->tab[2] = 3;

        free(mon_tableau[0]->tab);

        for (int i = 0; i < nb_de_sous_tableaux; i++) {
                free(mon_tableau[i]);
        }
        free(mon_tableau);

        return 0;
}

Votre code là est trés interessant et j'ai tout compris,la partie là plus particuliérement:

 mon_tableau[0]->taille = 3;
        mon_tableau[0]->tab = malloc(sizeof(int) * 3);
        mon_tableau[0]->tab[0] = 1;
        mon_tableau[0]->tab[1] = 2;
        mon_tableau[0]->tab[2] = 3;

        free(mon_tableau[0]->tab);

Ici vous savez d'avance ce qu'il faut mettre1,2,3..
J'ai essayé de généraliser tous ca en faisant

compteur
Parcourir le tableau
mon_tableau[0]->taille =compteur
Dans mon code le compteur compte les éléments a mettre dans chaque tab et il marche j'ai vérifié
Aprés j'ai fait
Pour j allant de 0 au nombre de sous tableaux que je veux
Pour k allant de 0 au nombre d'elements que je veux dans mon tableau(donné par mon compteur)
mon_tableau[j]->tab[k] = T.tab[i];

Ca marche pas trés bien
CE que j'essaye de fairec'est si j'ai T=[1,2,3,4,5,-1,2,3] avoir:
mon_tableau[0]->taille = 5;
mon_tableau[0]->tab = malloc(sizeof(int) * 5);
mon_tableau[0]->tab[0] = T[0];
mon_tableau[0]->tab[0] = T[1];
mon_tableau[0]->tab[0] = T[2];
mon_tableau[0]->tab[0] = T[3];
mon_tableau[0]->tab[0] = T[4];

mon_tableau[0]->tab = malloc(sizeof(int) * 2);
mon_tableau[1]->tab = malloc(sizeof(int) * 2);
mon_tableau[0]->tab[1] = T[6];
mon_tableau[0]->tab[1] = T[7];

Ma derniere question et c'est fini pour mon sujet

leoliom · Answer

Avant de répondre a votre question ,j'ai remarqué que lorsque je veux tester votre realloc ca marche pas

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

typedef struct tableau {
    int taille;
    int *tab;
    int T_MAX;
}tableau;






tableau creer_tab_vide(){
 tableau t;
 t.taille = 0;
 t.T_MAX=10;
 t.tab = malloc(10* sizeof(int));
 return t;
    
    
}
tableau ajouter_entier(tableau t,int n){
    int * temp;
     size_t new_T_MAX = 2 * t.T_MAX * sizeof(int);
     temp=realloc(t.tab, new_T_MAX);
     if (temp == NULL) {
          printf("Reallocation impossible : impossible d'ajouter un entier\n");
          return t;
      } else {
          t.tab = temp;
          t.T_MAX =  new_T_MAX;
      }

    t.taille=t.taille+1;
    int dernier_indice=t.taille-1;
    
    t.tab[dernier_indice]=n;
    return t;
    
}

void afficher_tableau(tableau T){
 int i;
 printf(" [");
 for (i = 0; i < T.taille; i++){ 
  
  printf("%d  ",T.tab[i]);
 } 
 printf("]\n");
}


int main(void){
    
    tableau t;
   t=creer_tab_vide();
    t=ajouter_entier(t,1);
    t=ajouter_entier(t,2);
    t=ajouter_entier(t,3);
    t=ajouter_entier(t,4);
    t=ajouter_entier(t,-1);
    t=ajouter_entier(t,6);
    t=ajouter_entier(t,7);
    t=ajouter_entier(t,8);
    t=ajouter_entier(t,-1);
   t=ajouter_entier(t,19);
    afficher_tableau(t);
   return 0;
}

Ca m'affiche Reallocation impossible : impossible d'ajouter un entier et s'arrete au 2ieme -1 au dela c'est impossible

Ca marche que a petite échelle

leoliom · Answer

Merci pour votre aide,je vais en finir là,j'ai passé trop de temps su cette exo

Merci encore

leoliom · Answer

Oui j’ai appris beaucoup de chose merci encore❤️

Tableaux à diverses dimensions avec diverses taille

26 réponses

Discussions similaires

Newsletters