Discussion :

[stotoro]

salut, je veux programmer la méthode de classification hiérarchique ascendente , alors je commence avec calculer la matrice distance d'un fichier texte qui contient une matrice de 6 ligne et 2 colonne.
le problème c'est au début c'est dans la fonction

j'utilise une classe calcule et appeler ces méthodes dans le main .
la classe calcule.cpp

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
#include "Calcule.h"
#include <iostream>
#include<fstream>
#include<math.h>
 
 
 
using namespace std;
 
 
 
Calcule::Calcule(char *fileName)
{
 
ifstream file(fileName);   //ouverture de fichier 
 
if (!file.is_open())
 
	    cout << "IMPOSSIBLE D'OUVRIRE LE FICHIER !" << endl;
 
    else
 
	   { 
		   file>>nbl;
		   file>>nbc;
 
		 /* Allocation dynamique de la matrice  */
    data = new float* [nbl];
    for (int i=0; i < nbl; i++)
    data[i] = new float[ nbc ];
 
	      /* lire la matrice depuis le fichier */ 
		 float tmp;
		for(int i=0;i<nbl;i++){
		 for(int j=0;j<nbc;j++){
			file>>tmp;
		    data[i][j]= tmp;
					}
		       }
		/////////////////////
		//*afficher la matrice ////
		for(int i=0;i<nbl;i++){
		   for(int j=0;j<nbc;j++)
		            {
               cout << data [i][j]  << " " ;
		            }
		           cout << endl;
		          }
}
}
///////////////////////////////////////////////////////////////////////////////
void Calcule::Afficher( float **mat){
	for(int i=0;i<nbl;i++){
		   for(int j=0;j<nbc;j++)
		            {
               cout << mat [i][j]  << " " ;
		            }
		           cout << endl;
		          }
}
/////////////////////////////////////////////////////////////////////////
float Calcule:: calcule_dis(float **data){
	 /* Allocation dynamique de la matrice  */
	float ** dist = new float* [nbl];
    for (int i=0; i < nbl; i++)
    dist[i] = new float [ nbc ];
	/////////////////////
	for( int i=0;i<nbl;i++ ){
     for (int j=0; j<nbl ; j++){
      for (int k=0; k <nbc; k++){ 
 
            dist[i][j]=(float)pow(data[i][k]-data[j][k], 2 ); 
          } } }
 for( int i=0;i<nbl;i++ ){
 for (int j=0; j<nbl ; j++){ 
  return dist[i][j]= sqrt(dist[i][j]); 
} } 
 
 
}	
//////////////////////////////////////////////
Calcule::~Calcule(){
	delete []data;
}

calcule.h

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
 
#include<fstream>
 
#pragma once
class Calcule
{
 
		float  **data;
		float **dist;
		int nbl, nbc;
 
 
public:
	Calcule(char *fileName);
     void Afficher(float ** mat);
    float calcule_dis(float **data);
 
 
 
	~Calcule();
};

le main

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
 
 
#include<iostream>
#include "Calcule.h"
#include<vector>
#include<math.h>
 
    using namespace std;
	float  **data;
	float **dist;
 
 
int main(  ){
 
Calcule *C=new Calcule("val.txt");  //creer un objet de la classe Calcule 
 
C->calcule_dis(data);
C->Afficher(dist);
 
 
C->~Calcule();//destruire l'objet
 
system("pause");
return 0;
}

il y'a pas des erreurs mais sa !!!!

[dalfab]

Bonjour,

la table dist est créée comme [nbl][nbc] est est utilisée comme une matrice carrée [nbl][nbl].

[stotoro]

Bonjour,

la table dist est créée comme [nbl][nbc] est est utilisée comme une matrice carrée [nbl][nbl].

merci pour votre réponse, j'ai pas réussi a utiliser la matrice dist

[Pyramidev]

Bonjour,

Dans ton module définissant main(), data est une variable globale. Il n'en existe qu'une seule instance lors de l'exécution du programme. Tu l'utilises sans l'initialiser. C'est probablement ce qui a entraîné le crash de ton programme.
Dans ta classe Calcule, il y a un membre qui s'appelle data, mais le compilateur se moque qu'elle porte le même nom que ta variable globale, car elle n'a rien à voir. Au cours de l'exécution du programme, à chaque instant, il existe autant d'instances de Calcule::data que d'objets Calcule.

A part ça, il y a aussi énormément d'autres problèmes dans ce code.
En voici une liste incomplète :

• Ton code n'est pas indenté.
• Tu devrais créer une classe qui s'appelle Matrice. Ensuite, ta fonction qui calcule une distance avec une autre matrice devrait prendre en paramètre un const Matrice & plutôt qu'un float**.
• Ta fonction Calcule::Afficher a accès à une matrice à travers tes membres Calcule::nbl, Calcule::nbc et Calcule::data. Elle prend en compte les deux premiers mais ignore le 3e au profit d'un paramètre float ** mat. Ce n'est pas cohérent.
• Ta fonction Calcule::calcule_dis n'a aucun sens.
• Ton destructeur Calcule::~Calcule ne libère pas correctement la mémoire. Avant de faire un delete[] sur data, il faut aussi en faire un sur chaque data[i]. Ou alors, tu peux laisser ton destructeur ainsi si tu corrige le problème ci-dessous.
• Quand tu construis la matrice, tu appelles new autant de fois que le nombre de lignes + 1. Ce n'est pas performant. Il vaut mieux allouer d'un coup un tableau de taille nbLignes x nbColonnes. Par exemple, tout coefficient (i, j) sera l'élément numéro i + j x nbLignes de ton tableau (si la numérotation commence à 0). D'ailleurs, ce n'est qu'à cette condition que, dans ton destructeur, tu peux n'appeler qu'une seule fois delete[] sans provoquer de fuite mémoire.

Il reste beaucoup à dire, mais je m'arrête là pour l'instant.

[stotoro]

Bonjour,

Dans ton module définissant main(), data est une variable globale. Il n'en existe qu'une seule instance lors de l'exécution du programme. Tu l'utilises sans l'initialiser. C'est probablement ce qui a entraîné le crash de ton programme.
Dans ta classe Calcule, il y a un membre qui s'appelle data, mais le compilateur se moque qu'elle porte le même nom que ta variable globale, car elle n'a rien à voir. Au cours de l'exécution du programme, à chaque instant, il existe autant d'instances de Calcule::data que d'objets Calcule.

A part ça, il y a aussi énormément d'autres problèmes dans ce code.
En voici une liste incomplète :

• Ton code n'est pas indenté.
• Tu devrais créer une classe qui s'appelle Matrice. Ensuite, ta fonction qui calcule une distance avec une autre matrice devrait prendre en paramètre un const Matrice & plutôt qu'un float**.
• Ta fonction Calcule::Afficher a accès à une matrice à travers tes membres Calcule::nbl, Calcule::nbc et Calcule::data. Elle prend en compte les deux premiers mais ignore le 3e au profit d'un paramètre float ** mat. Ce n'est pas cohérent.
• Ta fonction Calcule::calcule_dis n'a aucun sens.
• Ton destructeur Calcule::~Calcule ne libère pas correctement la mémoire. Avant de faire un delete[] sur data, il faut aussi en faire un sur chaque data[i]. Ou alors, tu peux laisser ton destructeur ainsi si tu corrige le problème ci-dessous.
• Quand tu construis la matrice, tu appelles new autant de fois que le nombre de lignes + 1. Ce n'est pas performant. Il vaut mieux allouer d'un coup un tableau de taille nbLignes x nbColonnes. Par exemple, tout coefficient (i, j) sera l'élément numéro i + j x nbLignes de ton tableau (si la numérotation commence à 0). D'ailleurs, ce n'est qu'à cette condition que, dans ton destructeur, tu peux n'appeler qu'une seule fois delete[] sans provoquer de fuite mémoire.

Il reste beaucoup à dire, mais je m'arrête là pour l'instant.

merci pour votre réponse , je suis une débutante en c++

[dragonjoker59]

Salut!

J'ajouterais que plutôt que faire des tableaux dynamiques à la C, utilise les std::vector, ça marche bien, et ça évite 1) les new/delete, 2) les memory leaks en cas d'exception.

[JolyLoic]

Je plussoie la réponse précédente, d'autant plus si tu es débutante : Oublie les tableaux à la C, les pointeurs, les pointeurs de pointeurs... et utilise les vector, c'est plus simple, et plus robuste, et en général, si tu compiles dans un mode debug, ils font des vérifications supplémentaires qui te permettent de détecter tout un tas de petites erreurs bêtes, comme par exemple un débordement d'indice de tableau, et qui autrement sont très difficiles à trouver.

[stotoro]

Je plussoie la réponse précédente, d'autant plus si tu es débutante : Oublie les tableaux à la C, les pointeurs, les pointeurs de pointeurs... et utilise les vector, c'est plus simple, et plus robuste, et en général, si tu compiles dans un mode debug, ils font des vérifications supplémentaires qui te permettent de détecter tout un tas de petites erreurs bêtes, comme par exemple un débordement d'indice de tableau, et qui autrement sont très difficiles à trouver.

ok ! merci

[stotoro]

Salut!

J'ajouterais que plutôt que faire des tableaux dynamiques à la C, utilise les std::vector, ça marche bien, et ça évite 1) les new/delete, 2) les memory leaks en cas d'exception.

d'accord je vais essayer les vectors , merci