la distance euclidienne en c++ avec les classes

**stotoro** · 19/05/2016, 20h11

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 !!!!

Nom : bb.PNG
Affichages : 794
Taille : 69,8 Ko

**dalfab** · 19/05/2016, 21h55

Bonjour,

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

**Pyramidev** · 19/05/2016, 21h59

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** · 19/05/2016, 22h06

Envoyé par dalfab

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

**stotoro** · 19/05/2016, 22h08

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

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

**dragonjoker59** · 19/05/2016, 22h23

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** · 20/05/2016, 00h05

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** · 20/05/2016, 00h09

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

d'accord je vais essayer les vectors , merci

**stotoro** · 20/05/2016, 00h11

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

ok ! merci

**Pyramidev** · 20/05/2016, 01h44

@dragonjoker59 et JolyLoic :
Oui, mais on ne sait pas si elle a déjà vu en cours le cas où un membre d'une classe est un objet (en l'occurrence un objet de type std::vector<float>) et pas un entier, booléen, flottant ou pointeur.
Sans parler du fait que std::vector est un template.

**dragonjoker59** · 20/05/2016, 09h35

using FloatArray = std::vector< float >; // Et hop! N'a plus template!

Et je ne vois pas en quoi le fait que le membre soit un objet plutôt qu'un type de base change quoi que ce soit...

**Pyramidev** · 20/05/2016, 17h36

Envoyé par dragonjoker59

Et je ne vois pas en quoi le fait que le membre soit un objet plutôt qu'un type de base change quoi que ce soit...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class Matrice
{
public:
    Matrice(unsigned nbLignes, unsigned nbColonnes);
    ~Matrice();
    // ...
private:
    unsigned           m_nbLignes;
    unsigned           m_nbColonnes;
    std::vector<float> m_data;
};

Ce qui change, c'est que le constructeur de m_data sera forcément appelé juste avant le corps du constructeur de Matrice et que le destructeur de m_data sera forcément appelé juste après le corps du destructeur de Matrice.
Pour faire du code que l'on comprend soit-même, cela demande un peu plus de connaissances qu'avec les types comme les entiers et les pointeurs.

**stotoro** · 20/05/2016, 18h30

est ce que tout mon code est erroné !!!! il y'a pas de solution ?

**Pyramidev** · 21/05/2016, 18h59

Je pense que, dans ton cas, dans un premier temps, le plus important est que tu puisses analyser comment se comporte un bout de code C++ sur lequel du travailles.

Par exemple, dans ton main, quand tu appelles :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

C->calcule_dis(data);

Voici comment se comporte l'appel de ta fonction :

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
float Calcule::calcule_dis(float **data){
    // On a appelé C->calcule_dis(data)
    // Le paramètre formel "data" est une copie du paramètre effectif "data" (celui de "C->calcule_dis(data)")
    // qui est une variable globale du module qui définit "main()".
    // Comme cette variable globale n'était pas initialisée, elle contient une valeur indéterminée
    // et produira probablement un crash du programme.
 
    // A part ça, comme le paramètre formel de cette fonction s'appelle "data",
    // alors "data" ne correspond pas à "Calcule::data", mais au paramètre formel de la fonction.
 
    float ** dist = new float* [nbl];
    for (int i=0; i < nbl; i++)
        dist[i] = new float [ nbc ];
    // Dans les lignes ci-dessus, on crée une variable "dist" locale à cette fonction
    // qui n'a rien à voir avec la variable globale "dist" du module qui définit "main()".
    // On alloue nbl tableaux de taille nbc. "dist" représente alors une matrice.
 
    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 );
                // La ligne ci-dessus suppose que dist a nbl lignes et nbl colonnes
                // (faux : dist a nbc colonnes)
                // et que data a nbl lignes et nbc colonnes.
            }
            // Dans la boucle ci-dessus, on écrit nbc fois dans dist[i][j], donc
            // c'est la dernière itération qui détermine la valeur de dist[i][j].
            // S'il n'y avait pas eu de crash, le code précédent équivalait à :
            // dist[i][j]=(float)pow(data[i][nbc-1]-data[j][nbc-1], 2 );
        }
    }
 
    for( int i=0;i<nbl;i++ ){
        for (int j=0; j<nbl ; j++){ 
            return dist[i][j]= sqrt(dist[i][j]);
            // A la première itération, on remplace dist[0][0] par sa racine carrée.
            // Ensuite, on retourne le contenu de dist[0][0].
            // Au final, c'est comme si on avait retourné
            // sqrt((float)pow(data[0][nbc-1]-data[0][nbc-1], 2 ))
            // c'est à dire 0.
            // Comme on a utilisé "return", les itérations suivantes ne seront jamais exécutées.
        }
    }
 
    // Le contenu de la matrice dist n'a pas été libéré donc, en plus, on a une fuite mémoire.
}

En apprenant les règles du C++ (du moins celles qui concernent les fonctionnalités du C++ que tu utilises) puis en t'entraînant à exécuter pas à pas dans ta tête le code que tu écris, tu pourras corriger plein de problèmes de manière autonome.
Ça demande surtout du temps et du travail. Bon courage.

**JolyLoic** · 22/05/2016, 02h59

Envoyé par Pyramidev

Ce qui change, c'est que le constructeur de m_data sera forcément appelé juste avant le corps du constructeur de Matrice et que le destructeur de m_data sera forcément appelé juste après le corps du destructeur de Matrice.

Et ? Qu'est-ce que ça apporte de fondamental à la compréhension du code ? Tout ce qui compte, c'est que vector est un tableau à taille variable, et qu'il faut oublier les float[], reliques d'un temps révolu. Comme toute donnée membre d'une classe, sa durée de vie est la même que celle de la classe, pas besoin d'aller au delà pour l'utiliser à pleine puissance.

Envoyé par Pyramidev

Pour faire du code que l'on comprend soit-même, cela demande un peu plus de connaissances qu'avec les types comme les entiers et les pointeurs.

Ça dépend de ce qu'on appelle comprendre. Si pour toi comprendre, c'est avoir une bonne vision de ce que le compilateur va générer comme code dans ton dos, certes, ça demande plus de boulot. Beaucoup plus. Et même comprendre comment marche une multiplication peut devenir non trivial dans ce contexte...

Mais si c'est comprendre comment marche ton code, ton algorithme, comprendre que vector est un tableau de taille variable et que tu n'as pas à te préoccuper d'autre chose, pas de soucis. Tu n'as même pas vraiment besoin de la notion de constructeur/destructeur ni même d'allocation mémoire pour utiliser pleinement vector en comprenant ce que tu fais.

Après, à un moment, ces notions deviendront nécessaires pour progresser. Mais mon expérience est que la courbe d'apprentissage est plus douce, et le rapport récompense/effort bien plus intéressant quand tu commences à utiliser vector comme un type opaque "magique", et que tu ne soulèves le capot que plus tard.

**Bousk** · 22/05/2016, 12h08

Envoyé par Pyramidev

Ce qui change, c'est que le constructeur de m_data sera forcément appelé juste avant le corps du constructeur de Matrice et que le destructeur de m_data sera forcément appelé juste après le corps du destructeur de Matrice.

Et vu que ce constructeur et destructeur ne font pas grand chose qui nous intéresse, ne risquent pas de générer exception ou fuite mémoire : on s'en moque.
Un débutant, qu'il manipule un int, une string ou un vector, c'est kifkif.
S'il commence à s'amuser à mettre des pointeurs dans son vector, on est déjà une étape au-dessus. Et encore, tu fous un vector de unique_ptr et basta : tu t'en soucies pas plus.

**koala01** · 24/05/2016, 18h38

Salut,

Après avoir plussoté à certains, je ne peux m'empêcher d'intervenir pour confirmer ce qu'ils ont déjà dit : la gestion manuelle de la mémoire (à coup de new et de delete) N'EST PAS UNE NOTION ADAPTEE AUX DEBUTANTS.

Et, les non débutants préféreront toujours ou bien carrément éviter d'y avoir recours, ou bien utiliser des techniques (pointeurs intellegents entre autres) qui permettront d'éviter ou de contourner la plupart des problèmes que ce phénomène peut occasionner.

La classe std::vector (et bien d'autres) nous permettent de prendre en charge tout l'aspect relatif à la gestion dynamique de la mémoire sans que le développeur n'ait à s'en inquiéter; et mieux encore : ces classes s'en occupent particulièrement bien.

Tant que l'on a la garantie que std::vector correspond à la notion "tableau de données" et que ces données sont bel et bien contigües en mémoire, il n'est ABSOLUMENT PAS NECESSAIRE d'aller plus loin dans la compréhension (du moins au début). Et il se fait que l'on a cette garantie, que la classe vector est, justement, une collection dont le fonctionnement est prévu pour garantir la contiguïté des données en mémoire.

Je ne nie, bien sur, absolument pas tout l'aspect formateur qu'il peut y avoir à s'intéresser à la gestion de la mémoire, mais, je rejoins pleinement jolyloic pour dire que cet aspect particulier ne devrait être abordé qu'une fois que l'étudiant a atteint un certain niveau, qu'il a acquis un minimum de bouteille pour se rendre compte de tous les pièges qu'il peut y avoir à l'utiliser, et, surtout, pour qu'il ne commence à l'utiliser que lorsqu'il n'a définitivement pas d'autre choix, et, tant qu'à faire, qu'il apprenne à y avoir recours en s'entourant des précautions susceptibles d'éviter les catastrophes (encore une fois, je parle des pointeurs intelligents).

la distance euclidienne en c++ avec les classes

C++

Discussions similaires

Partager

Partager