IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Allocation dynamique sur tableau 2D


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Alternant sécurité informatique
    Inscrit en
    Novembre 2019
    Messages
    16
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Alternant sécurité informatique

    Informations forums :
    Inscription : Novembre 2019
    Messages : 16
    Par défaut Allocation dynamique sur tableau 2D
    Bonjour, j'aimerais faire une fonction qui alloue dynamiquement un tableau 2D mais en seulement 2 malloc et la même fonction en seulement 1 malloc. J'ai déjà tenté ça mais le programme crash et je ne sais pas pourquoi. Merci d'avance.

    En 1 malloc
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    int** initTab(int N, int M){
     
        int** tab = (int**) malloc( (sizeof(int*)*N*M );
     
        return tab;
    }
    En 2 malloc
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    int** initTab(int N, int M){
     
        int** tab = (int**) malloc(sizeof(int*)*N);
     
        int** tab2 = (int*) malloc(sizeof(int)*M);
     
       return tab; 
    }

  2. #2
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    27 127
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 27 127
    Billets dans le blog
    149
    Par défaut
    Bonjour,

    Déjà, il est difficile de savoir pourquoi cela crashe, car le seul code que vous donnez, c'est celui de l'allocation (qui d'après moi, ne va pas crasher, sauf cas très improbable).

    Dans le premier cas, vous alliez N * M int*, alors qu'il faudrait plutôt allouer N * M intDans le second cas, il me semble qu'il faille une boucle for. Du coup, il faut écrire deux malloc, toutefois, à l'exécution, ce sont plus de deux mallocs qui vont être réalisés.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Membre averti
    Homme Profil pro
    Alternant sécurité informatique
    Inscrit en
    Novembre 2019
    Messages
    16
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Alternant sécurité informatique

    Informations forums :
    Inscription : Novembre 2019
    Messages : 16
    Par défaut
    C'est des exercices que je dois faire en cours donc je n'ai pas accès au reste du code, je ne dois écrire que la fonction demandé. Voici l'intitulé de l'exercice :

    Complétez la fonction pour qu'elle alloue et retourne un tableau de NxM cases.

    Chaque case (i,j), telle que 0<=i<N, et 0<=j<M, sera accessible via tab[i][j] si tab est le nom donné au tableau retourné, et sera initialisée à i+j.

    L'allocation devra se faire en 2 mallocs.

    Et j'ai fait que tu m'as conseillé, mais ce n'est pas ce qui est demandé

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    int** initMatrix(int N, int M){
     
        int** tab = (int**) malloc(sizeof(int*)*N);
     
        for(int i=0; i<N; i++){
     
            tab[i] = (int*) malloc(sizeof(int)*M);
     
            for(int j=0; j<M; j++){
                tab[i][j]=i+j;
            }
        }
     
       return tab; 
    }
    Résultat :
    Nom : Capture.PNG
Affichages : 5598
Taille : 15,6 Ko

    Au vu de l'indication, je comprend bien qu'il faut enlever la boucle et faire qu'un malloc de N*M, mais je ne sais pas où la faire pointer. J'ai tenté ça mais ça crash :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    int** initMatrix(int N, int M){
     
        int** tab = (int**) malloc(sizeof(int*)*N);
     
        *tab = (int*) malloc(N*M);
     
         for(int i=0; i<N; i++){
            for(int j=0; j<M; j++){
                tab[i][j]=i+j;
            }
        }    
     
     
     
       return tab; 
    }

  4. #4
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 835
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 835
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par Adiren Voir le message
    Complétez la fonction pour qu'elle alloue et retourne un tableau de NxM cases.

    Chaque case (i,j), telle que 0<=i<N, et 0<=j<M, sera accessible via tab[i][j] si tab est le nom donné au tableau retourné, et sera initialisée à i+j.

    L'allocation devra se faire en 2 mallocs.

    Et j'ai fait que tu m'as conseillé, mais ce n'est pas ce qui est demandé

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    int** initMatrix(int N, int M){
     
        int** tab = (int**) malloc(sizeof(int*)*N);
     
        for(int i=0; i<N; i++){
     
            tab[i] = (int*) malloc(sizeof(int)*M);
     
            for(int j=0; j<M; j++){
                tab[i][j]=i+j;
            }
        }
     
       return tab; 
    }
    Mais si. Il y a bien 2 malloc dans cette fonction !!!

    Citation Envoyé par Adiren Voir le message
    Au vu de l'indication, je comprend bien qu'il faut enlever la boucle et faire qu'un malloc de N*M, mais je ne sais pas où la faire pointer. J'ai tenté ça mais ça crash :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    int** initMatrix(int N, int M){
     
        int** tab = (int**) malloc(sizeof(int*)*N);
     
        *tab = (int*) malloc(N*M);
     
         for(int i=0; i<N; i++){
            for(int j=0; j<M; j++){
                tab[i][j]=i+j;
            }
        }    
     
     
     
       return tab; 
    }
    Normal. Il ne faut pas perdre de vue que tu dois obtenir en final des cases. La première méthode te fait allouer N pointeurs puis chaque pointeur te fait allouer M cases. Donc tu as bien des cases au final (et en 2 malloc comme demandé)
    La seconde méthode doit te faire allouer aussi des cases mais en une seule opération. Comme un jeu d'échecs de N*M cases (et non N*M pointeurs). Bref dans cette seconde méthode, tu n'as droit qu'à un malloc donc tu dois partr d'un int * et non d'un int **. Ton tout premier essai sur cet exo était presque ça.
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  5. #5
    Membre averti
    Homme Profil pro
    Alternant sécurité informatique
    Inscrit en
    Novembre 2019
    Messages
    16
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Alternant sécurité informatique

    Informations forums :
    Inscription : Novembre 2019
    Messages : 16
    Par défaut
    Je ne montrais que la fonction avec 2 malloc, et comme un malloc est dans une boucle, ce n'est pas 2 malloc mais en N+1.

    Et merci, pour les indications avec qu'1 malloc, je vais retenter

  6. #6
    Membre émérite
    Avatar de emixam16
    Homme Profil pro
    Chercheur en sécurité
    Inscrit en
    Juin 2013
    Messages
    335
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Calvados (Basse Normandie)

    Informations professionnelles :
    Activité : Chercheur en sécurité

    Informations forums :
    Inscription : Juin 2013
    Messages : 335
    Par défaut
    Bonjour,

    Alors, pour la version avec un seul malloc, il faut que tu utilises un tableau 1D comme un tableau 2D.

    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    #define WIDTH 10
    #define HEIGHT 10
    int* matrix = malloc(WIDTH * HEIGHT  * sizeof(int));
    // [...]
    // Exemple mise a 42 de l'élément matrix[i][j]
    matrix[i*WIDTH +j] = 42;
    Tu peux éventuellement utiliser des defines pour simplifier les écritures/lectures.


    Pour la version a 2 mallocs c'est un peu plus subtil. Tu alloues tout en une fois comme un tableau contigu et tu fais pointer sur les bons éléments.
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    int** matrix= malloc(WIDTH *sizeof(int*));
    int* tmpptr = malloc(WIDTH * HEIGHT *sizeof(int))
    for(int i=0;i<WIDTH ;++i) {
       matrix[i] = tmpptr;
       tmpptr += HEIGHT;
    }

    (On peut faire beaucoup plus cours que ce code, mais cette version me semble pédagogique. Attention je n'ai pas testé ces codes).


    En réutilisant la deuxième approche tu peux passer très simplement à un seul malloc tout en gardant un int**. Si tu as compris le principe tu dois être capable de l'adapter tout seul!

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. allocation dynamique à un tableau
    Par amateurc dans le forum Débuter
    Réponses: 4
    Dernier message: 25/06/2008, 20h24
  2. Réponses: 11
    Dernier message: 11/06/2008, 18h05
  3. Bug sur une allocation dynamique de tableau
    Par Atharendil dans le forum C++
    Réponses: 6
    Dernier message: 15/12/2007, 23h42
  4. Réponses: 9
    Dernier message: 12/06/2007, 14h15
  5. Réponses: 6
    Dernier message: 26/11/2005, 19h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo