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 matrices


Sujet :

C++

  1. #1
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2012
    Messages
    13
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2012
    Messages : 13
    Par défaut allocation dynamique matrices
    Bonjour,

    J'essaye d'allouer dynamiquement en mémoire un Labyrinthe 3D contenu de rangées, colonnes et plateaux.
    Chaque case peut être un mur, un passage, un dragon ou un trésor :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    enum typeCase { MUR , PASSAGE , DRAGON , TRESOR };
    Mon labyrinthe est défini comme ceci :

    et

    voici ce que j'ai déja fait pour la fonction d'allocation :

    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
    Lab*** alloc_lab(Lab*** lab, const Format f) {
     
        // Allocation du labyrinthe entier
        lab = (Lab***) malloc( sizeof(Lab)*(f.nbMatrix*f.row*f.colomn) );
     
        // Allocation des matrices
        for(unsigned int i=0;i<f.nbMatrix;i++) {
            lab[i] = (Lab**) malloc ( sizeof(Lab)*(f.row*f.colomn) );
            // Allocation des colonnes
            for(unsigned int j=0; j<f.row; j++)
                lab[i][j] = (Lab*) malloc ( sizeof(Lab)*f.colomn );
        }
     
        return lab;
    }
    Faut-il que j'alloue aussi les rangées ?

  2. #2
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2011
    Messages
    366
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Paris (Île de France)

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

    Informations forums :
    Inscription : Mai 2011
    Messages : 366
    Par défaut
    Citation Envoyé par asloon Voir le message
    Bonjour,

    J'essaye d'allouer dynamiquement en mémoire un Labyrinthe 3D contenu de rangées, colonnes et plateaux.
    Chaque case peut être un mur, un passage, un dragon ou un trésor :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    enum typeCase { MUR , PASSAGE , DRAGON , TRESOR };
    Mon labyrinthe est défini comme ceci :

    et

    voici ce que j'ai déja fait pour la fonction d'allocation :

    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
    Lab*** alloc_lab(Lab*** lab, const Format f) {
     
        // Allocation du labyrinthe entier
        lab = (Lab***) malloc( sizeof(Lab)*(f.nbMatrix*f.row*f.colomn) );
     
        // Allocation des matrices
        for(unsigned int i=0;i<f.nbMatrix;i++) {
            lab[i] = (Lab**) malloc ( sizeof(Lab)*(f.row*f.colomn) );
            // Allocation des colonnes
            for(unsigned int j=0; j<f.row; j++)
                lab[i][j] = (Lab*) malloc ( sizeof(Lab)*f.colomn );
        }
     
        return lab;
    }
    Faut-il que j'alloue aussi les rangées ?
    Premièrement, ce problème aurait plus sa place dans la partie C, même si, techniquement, c'est codable en C++.

    En admettant,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    // Allocation du labyrinthe entier
    lab = (Lab***) malloc( sizeof(Lab)*(f.nbMatrix*f.row*f.colomn) );
    Je ne comprends pas cette partie. Pourquoi ne pas allouer

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    lab = (Lab***) malloc( sizeof(Lab**)*(f.nbMatrix) );
    Puisque ensuite, tu alloues ligne à ligne des Lab**?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
       lab[i] = (Lab**) malloc ( sizeof(Lab)*(f.row*f.colomn) );

  3. #3
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2012
    Messages
    13
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2012
    Messages : 13
    Par défaut
    Ne faut il pas allouer d'abord le labyrinthe en entier puis les matrices et enfin les colonnes et les lignes ?

  4. #4
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2011
    Messages
    366
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Paris (Île de France)

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

    Informations forums :
    Inscription : Mai 2011
    Messages : 366
    Par défaut
    Citation Envoyé par asloon Voir le message
    Ne faut il pas allouer d'abord le labyrinthe en entier puis les matrices et enfin les colonnes et les lignes ?
    Si tu prends Lab** c'est un tableau de tableaux d'éléments. Si tu as 50 tableaux d'éléments, que chaque tableau d'éléments a 10 éléments, tu alloues d'abord 50 Lab* puis, pour chaque tableau un à un.
    Maintenant, si tu codes çà en C++ comme l'indique la rubrique, utiliser les pointeurs à grands coups malloc, c'est clairement une source de bugs.

  5. #5
    Membre Expert

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2007
    Messages
    1 895
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Septembre 2007
    Messages : 1 895
    Par défaut
    Le plus simple est d'allouer un seul tableau de N*M éléments (dans un objet) et de proposer des fonctions qui vont retrouver le type d'une case en fonction de ses coordonnées (x, y).

    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
     
    class labyrinth
    {
       std::vector<Lab> m_labs;
       int m_lines, m_cols; 
    public:
       labyrinth(int m, int n)
       : m_labs(m * n, Lab())
       , m_lines(n)
       , m_cols(m)
       { }
       Lab get(int x, int y) const
       { return m_labs[y * m_cols + x]; }
       void set(int x, int y, Lab lab)
       { m_labs[y * m_cols + x] = lab; } 
    };
    [FAQ des forums][FAQ Développement 2D, 3D et Jeux][Si vous ne savez pas ou vous en êtes...]
    Essayez d'écrire clairement (c'est à dire avec des mots français complets). SMS est votre ennemi.
    Evitez les arguments inutiles - DirectMachin vs. OpenTruc ou G++ vs. Café. C'est dépassé tout ça.
    Et si vous êtes sages, vous aurez peut être vous aussi la chance de passer à la télé. Ou pas.

    Ce site contient un forum d'entraide gratuit. Il ne s'use que si l'on ne s'en sert pas.

Discussions similaires

  1. allocation dynamique d'une matrice
    Par kochfet dans le forum C
    Réponses: 5
    Dernier message: 26/03/2014, 11h24
  2. Allocation dynamique d'une matrice
    Par cedrix57 dans le forum Fortran
    Réponses: 2
    Dernier message: 24/05/2010, 10h24
  3. Allocation dynamique d'une matrice
    Par magicstar dans le forum MATLAB
    Réponses: 7
    Dernier message: 27/04/2007, 09h51
  4. Allocation dynamique de mémoire en asm
    Par narmataru dans le forum Assembleur
    Réponses: 7
    Dernier message: 17/12/2002, 22h31
  5. Réponses: 4
    Dernier message: 03/12/2002, 16h47

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