Problème avec l'affichage d'une classe matrice [Résolu]

Signaler
Messages postés
9
Date d'inscription
samedi 24 décembre 2005
Statut
Membre
Dernière intervention
24 novembre 2006
-
Messages postés
9
Date d'inscription
samedi 24 décembre 2005
Statut
Membre
Dernière intervention
24 novembre 2006
-
J'ai recontrer un problème complètement fou à mes yeux en voulant creer un classe matrice, qui effectue des calcul de base sur les matrice.
voilà le code complet :

//---------------------------------------------------------------------------------
//    matrice.h
//---------------------------------------------------------------------------------

class matrice{

    int *tab;      // pointeur sur le tableau représentant la matrice
    int L;         // dimensions effective de la matrice
    int C;
    char *NOM;
    
public:
    
    // definition d'une matrice "vide": L=C=0
    matrice(char *nom);

    ~matrice();
        
    void init(int lignes, int colonnes);

    friend ostream& operator<<(ostream& o, matrice M);
};

//---------------------------------------------------------------------------------
//    matrice.cpp
//---------------------------------------------------------------------------------

#include
using namespace std;

#include "matrice.h"

matrice::matrice(char *nom)
{   
    L=0;
    C=0;
    tab=((int *)0);
    NOM=nom;
}

matrice::~matrice()
{
    if(tab!=((int *)0)) delete[] tab;
}

void matrice::init(int lignes, int colonnes)
{
    int i=0;
    if(lignes<=0 || colonnes<=0){       
        L=0; C=0;              // matrice "vide"
    }
    else if(tab!=((int *)0)){        // première initialisation

        C=colonnes;
        L=lignes;
        tab = new int[L*C];
        }
        else{                    // réinitialisation ultérieur avc d'autre dimensions

            delete[] tab;
            L=lignes;
            C=colonnes;
            tab= new int [L*C];

        }

        for(i=0; i<L*C; i++) tab[i]=1;   // on créé une matrice avc que d 1
}

ostream& operator<<(ostream& o, matrice M)
{
    int i,j;
    o<<endl<<M.NOM<<"=";
    for(i=1; i<=M.L; i++){
        o<<"\t";
        for(j=1; j<=M.C; j++)
            o<<M.tab[(i-1)*M.C+j-1]<<"\t";
        o<<endl;
    }

    o<<endl;
    
    return o;
}

//---------------------------------------------------------------------------------
//    main.cpp
//---------------------------------------------------------------------------------

#include <cstdlib>
#include

using namespace std;

#include "matrice.h"

int main()
{
    int lignes,colonnes;
    matrice M = matrice("M");
    M.init(3,3);
    
    cout<<M;

    cout<<M;

    cout<<M;

    M.~matrice();

    system("PAUSE");
    return EXIT_SUCCESS;
}

//---------------------------------------------------------------------------------
//    Après avoir compilé, j'obtient ça comme résultat :
//---------------------------------------------------------------------------------

M=      1       1       1     // première affichage ok !
        1       1       1
        1       1       1

M=      0       1       1       // pourquoi la première valeur est modifiée ???
        1       1       1
        1       1       1

M=      4013776 1       1   // est là encore une fois ?
        1       1       1
        1       1       1

Merci d'avance pour votre aide.

4 réponses

Messages postés
2333
Date d'inscription
samedi 28 février 2004
Statut
Membre
Dernière intervention
26 juillet 2013
36
Salut:

Pourquoi ce "M.~matrice ()" ?

Le destructeur sera appelé implicitement puisque tu utilises de l'allocation statique, si tu utilises de l'allocation dynamique de la mémoire il faut appeler delete
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
21
Tu organises tes boucles d'affichage en commençant à 1, alors qu'il faut commencer à 0.
De plus tu gagnerais en visibilité en créant une vrai matrice.

Exemple :

class Matrice
{
    int** m_t;
    int   m_nbrLignes;
    int   m_nbrColonnes;
public:
    Matrice(int=3, int=3);
    Matrice(const Matrice&);
    ~Matrice();
    friend Matrice operator * (int, const Matrice&);
    Matrice operator + (const Matrice&) const;
    const Matrice& oprator = (const Matrice&);
    friend istream& operator >> (istream&, Matrice&);
    friend ostream& operator << (ostream&, const Matrice&);
};


// Attrention au constructeur de copie !
Matrice::Matrice(const Matrice& matCopie)
{
    m_nbrLignes = matCopie.m_nbrLignes;
    m_nbrColonnes = matCopie.m_nbrColonnes;
    m_t = new int*[m_nbrLignes];
 
    for(int i=0; i<m_nbrLignes; i++)
    {
        m_t[i] = new int[m_nbrColonnes];
           for(int j=0; j<m_nbrColonnes; j++)
               m_t[i][j] = matCopie.m_t[i][j];
    }
}

// ect...
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
21
En fait le bug vient d'ici :

o << M.tab[(i-1) * M.C + j-1] << "\t";

pour chaque J tu es toujours a 0, donc tu affiches toujours la premiere case.
Messages postés
9
Date d'inscription
samedi 24 décembre 2005
Statut
Membre
Dernière intervention
24 novembre 2006

merci, d'vaoir ajouter quelque infos supplémentaire sur l'amélioration mon code.

Malheureusement je suis un débutant en C++ (j'en fait que depuis 2 mois), et donc je viens à peine de voir la notion de classe, ce qui fait que je ne vois pas très bien le sens de "vraie matrice", mais n'empêche que je vais essayer de comprendre ce que tu me propose.

Pour la critique sur l'affichage en commençant à 1 et non pas à 0, c'est pour que mes matrices puissent être utilisées avec la terminologie mathématique qui nomme le premier élément M[1][1] et non pas M[0][0]. (ce qui facilite le passage des "astuces" en maths aux "astuces" en info).

Si g bien compris l'utilité du for.
   for(j=1; j<=M.C; j++)
      o << M.tab[(i-1) * M.C + j-1] << "\t";
Ce bout de code implique que j varie.