Identificateur introuvable sur pointeur temporaire

Version imprimable

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:

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 !

04/04/2021, 17h26
dalfab

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++
04/04/2021, 18h11
Jules_Courné

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 ?

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:

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:

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é.

05/04/2021, 20h48
Astraya

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] )