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

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2021
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 24
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : janvier 2021
    Messages : 6
    Points : 4
    Points
    4
    Par défaut Identificateur introuvable sur pointeur temporaire
    Bonjour à tous,
    J'essaye de créer une fonction ayant pour but de supprimer une ligne en position posY dans une matrice de type générique. Cependant lorsque que j'alloue une matrice temporaire on me dit "Identificateur introuvable" et je ne vois pas comment régler ca.
    Je vous met le code :
    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
    17
    18
    19
    20
    21
    22
    23
    24
    25
    /*Le but de cette méthode est de supprimer une ligne d'un objet Matrice*/
    template<class MType>
    inline void CMatrice<MType>::MATSupprimerLigne(int posY)
    {
    	(MType**)pNewListe; // "identificateur introuvable"
    	pNewListe = (MType**)malloc((iMATNbLigne - 1) * sizeof(MType*));  //
    	for (int k = 0; k < iMATNbLigne - 1; ++k) {						  // On alloue la mémoire correspondant à notre matrice -1 ligne dans notre matrice temporaire.
    		pNewListe[k] = (MType*)malloc(iMATNbColonne * sizeof(MType)); //
    	}
     
    	for (int i = 0; i < posY; i++) {                   // 
    		for (int j = 0; j < iMATNbColonne; j++) {      // On recopie les valeurs de notre matrice pour les ligne allant de 0 à posY-1 (posY est la ligne à supprimer).
    			pNewListe[j][i] = pMATListe[j][i];		   //
    		}
    	}
    	for (int m = posY + 1; m < iMATNbLigne; m++) {		//
    		for (int n = posY; n < iMATNbLigne; n++) {		//      la matrice temporaire prend les valeurs de notre matrice pour les lignes supérieur à posY.
    			for (int r = 0; r < iMATNbColonne; r++) {	//
    				pNewListe[r][n] = pMATListe[r][m];		//
    			}
    		}
    	}			
    	&pMATListe = &pNewListe; //Notre matrice prend l'adresse de la matrice temporaire.
    	delete[] pNewListe;
    }
    Il y a surement beacoup d'erreurs autre que "identificateur introuvable" mais ce serait déja un début de comprendre celle-ci ^^. Merci d'avance !

  2. #2
    Expert éminent
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    1 259
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 1 259
    Points : 6 106
    Points
    6 106
    Par défaut
    Bonjour,

    Il faut ôter les parenthèses pour que ta ligne soit comprise. Ou à la rigueur les mettre ailleurs. MType** pNewListe; ou MType* (*pNewListe); ou MType (**pNewListe);.

    Mais les autres lignes sont bourrées d'erreurs, et elles sont gravissimes:
    - utilisation de malloc() !!!
    - multiples allocations dans une boucle.
    - tentative de modifier l'adresse d'une variable ligne 23, &pMATListe = &pNewListe;!! Et oubli de libérer proprement qui avait été alloué avant!!
    - ligne 24 : destruction par delete[] de quelque chose allouée avec malloc(). Mais surtout destruction de tout de que tu viens de créer!

    Dans les moins graves:
    - utilisation de cast du langage C. Un cast en C++ se fait avec static_cast<>().

    Il te faut :
    - apprendre ce qu'est un pointeur.
    - apprendre à ne pas t'en servir quand cela est possible.
    - ne pas utiliser new et delete à moins d'être un expert
    - encore moins utiliser malloc() dans un code C++

  3. #3
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2021
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 24
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : janvier 2021
    Messages : 6
    Points : 4
    Points
    4
    Par défaut
    Merci de ta réponse dalfab . En effet j'ai des gros problème de compréhension ^^. J'ai quelques question par rapport à ce que tu m'as dit : Comment puis allouer une nouvelle matrice sans malloc() et en evitant new ? Et aurais tu une autre méthode pour supprimer une ligne/colonne d'une matrice ?

  4. #4
    Expert éminent
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    1 259
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 1 259
    Points : 6 106
    Points
    6 106
    Par défaut
    Bonjour,

    Pour gérer un ensemble de données, il faut penser en premier aux objets faits pour cela. Les collections comme std::vector<,,> sont très biens.
    Si par contre tu souhaites toi même faire tes allocations, tu peux utiliser les pointeurs intelligents qui s'occupent automatiquement des désallocations. Tu as std::unique_ptr<,> pour faire le boulot.
    Tu pourrais descendre encore plus bas en utilisant new[] et delete[] mais même les experts s'y cassent les dents.

    Pour tes données, le plus simple et le plus efficace est d'utiliser un unique espace linéaire dans lequel du mettra tes lignes et tes colonnes de données.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    template<class MType>inline std::size_t  CMatrice<MType>::indiceXY( std::size_t col, std::size_t lig )const {
        return  lig * m_taille_colonne + col;
    }
    template<class MType>inline MType const&  CMatrice<MType>::XYItem( std::size_t col, std::size_t lig )const {
        return  m_data[ indiceXY( col, lig ) ];
    }
    La suppression d'une ligne peut se faire comme tu l'as fait. On crée un nouvel habitable pour les données, on copie ce qu'il faut et cet habitable devient les nouvelles données. On peut aussi directement "compresser" les données en terminant par le redimensionnement du tableau, mais ceci ne peut pas être utilisé pour l'ajout de colonnes/ligne. Si m_data est un std::vector<MType>, ça donne:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    template<class MType>void  CMatrice<MType>::MATSupprimerLigne( std::size_t lig ) {
        std::copy( m_data.begin()+indiceXY(0,lig+1), m_data.end(), m_data.begin()+indiceXY(0,lig) ); // copier les lignes après lig à partir de lig
        m_data.resize( m_data.size() - m_taille_colonne );  // une ligne de moins
    }
    Note que pour supprimer une colonne, c'est plus compliqué.

  5. #5
    Membre expérimenté Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    mai 2007
    Messages
    911
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : mai 2007
    Messages : 911
    Points : 1 739
    Points
    1 739
    Par défaut
    La suppression d'une ligne peut se faire avec un simple std::memmove.

    Je m'explique:
    Le C et C++ te garantissent que les tableaux sont en mémoire en row major order. Ce qui signifie que tu auras à la suite dans la mémoire la ligne 0, puis la ligne 1 etc, elles seront contiguës en mémoire (Ligne1Ligne2Ligne3...LigneN)
    Donc tu peux voir que supprimer une ligne 2 dans un tableau à 4 lignes contiguës signifient en faite de déplacer les lignes 3 et 4 sur la ligne 2 juste après la 1. Le memmove est fait pour ça.

    Tu verras également que tu peux sauver une allocation à chaque suppression car tu n'as pas à changer ton allocation tant que tu n'ajoutes pas plus de lignes que déjà allouée. Bien sûr tu auras n'importe quoi dans la mémoire ou tu n'es pas censé avoir de ligne. Tu dois donc garder la taille de ton tableau à côté et pas seulement la taille de l'allocation.

    Ça marche avec une allocation dynamique ( std::vector, new, malloc, unique_ptr) ou de simple allocation sur le pile ( int[4], int [4][4] )
    Homer J. Simpson


Discussions similaires

  1. Réponses: 3
    Dernier message: 11/01/2006, 17h23
  2. [PLUG IN HIBERNATE] introuvable sur le net
    Par PamelaGeek dans le forum Eclipse Java
    Réponses: 11
    Dernier message: 02/01/2006, 18h35
  3. fichier js introuvable sur serveur
    Par nerick dans le forum Général JavaScript
    Réponses: 1
    Dernier message: 13/12/2005, 14h16
  4. pointeur sur pointeur
    Par gaut dans le forum C
    Réponses: 3
    Dernier message: 01/11/2005, 21h30
  5. [Global temporary]Transaction sur table temporaire
    Par tanatiel dans le forum Oracle
    Réponses: 9
    Dernier message: 12/10/2005, 16h38

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