classe matrice

[invite389df8bf]

Bonjour,
je cherche à créer une classe matrice dont le but est de faire le produit matrice vecteur, en c++ sans utiliser std::vector. Ci dessous le programme que j'ai fait, chez moi il compile, mais peut être qu'il y'a des erreurs que je n'ai pas vu. Ma question est: comment définir le produit d'un vecteur avec une matrice, ce qui me dérange c'est quelle taille donner à la matrice pour qu'elle soit considérée comme un vecteur? Je vous remercie par avance pour votre aide.

#ifndef _MATRICE_HPP_
#define _MATRICE_HPP_
 #include <algorithm>
#include <iostream>
 
 
class Matrice
{
  private:
    int taille_;
    int **matrice_; 


  public:
   //Déclaration et Définition d'un constructeur par défaut
    Matrice() : taille_(0), matrice_(0){};


    //Déclaration d'un constructeur avec argument
    explicit Matrice (int n=0); 

    //Déclaration d'un constructeur de copie
    Matrice(const Matrice& ref);

     //Déclaration d'un déstructeur
    ~Matrice();

    //Déclaration de l'opérateur =
    Matrice operator=(const Matrice &); 

    
   // Méthode d'accès à une valeur de la matrice
    int getTaille() const;
     
 
    // Méthode de modification de la taille de la matrice
    int getVal(int i, int j) const;
     
    
   
  //friend std :: ostream& operator<<(std :: ostream &ostr, const Matrice &m); 

  //friend std :: istream& operator>>(std :: istream &is, Matrice &m);
          

};
 

//Définition du constructeur avec argument
Matrice :: Matrice(int n): taille_(n), matrice_(0)
{
  //création de l'espace mémoire pour int** matrice_ de taille n
   matrice_=new int * [taille_];
   for(int i=0; i<taille_; i++)
     matrice_[ i]=new int [taille_];
  //on initialise les valeurs de la matrice à 0
   for (int i=0; i<taille_; i++)
    {
      for (int j=0; j<taille_; j++)
       matrice_[ i][ j]=0;
     }
}
 

//Définition du constructeur de copie
Matrice :: Matrice(const Matrice& ref): taille_(ref.taille_), matrice_(nullptr)
{
    if(taille_ != 0)
    {
        matrice_ = new int*[taille_];           // 
        for(size_t i=0; i<taille_;i++)
               matrice_[ i]=ref.matrice_[ i];
    }
}



//Définition du destructeur pour éviter les problèmes de fuite de mémoire
Matrice :: ~Matrice()
{ 
    delete[] matrice_;
    matrice_ = nullptr;
    taille_ = 0;
}

  
//Définition de =
Matrice Matrice :: operator=(const Matrice &m)
{
    if(m.matrice_ != matrice_){ // garde contre "self assignment"
        // dealocation du *this
        delete [] matrice_;
        taille_ = 0;
        matrice_ = nullptr;
        if(m.taille_ != 0){
            matrice_ = new int*[m.taille_];
            taille_ = m.taille_;
           for(size_t  i=0;i<taille_;i++)
           {
               matrice_[ i]=m.matrice_[ i];
           }
        }
    }
    return *this;
}




//Définition de getTaille
int Matrice :: getTaille() const
{
    return taille_;
}
 
 
//Définition de getVal
int Matrice :: getVal(int i, int j) const
{
    return matrice_[ i][ j];
}
  

#endif

-----

[imoca]

Ici, ta classe matrice est celle des matrices carrées.
Si tu créé une classe plus générale ie les matrices ayant n lignes et m colonnes. Par héritage, tu peut créer une classe matrice carrée (n=m) et une vecteur (m=1).

[invite389df8bf]

J'ai bien essayé de le faire, mais le compilateur mer renvoie des erreurs, je n'ai pas su introduire le nombre de ligne et le nombre de colonne correctement pour définir tous les constructeurs. Aidez moi s'il vous plaît à le corriger

#ifndef _MATRICE_HPP_
#define _MATRICE_HPP_
 #include <algorithm>
#include <iostream>
 
 
class Matrice
{
  private:
    int nb_ligne;
    int nb_colonne;
    int **matrice_; 


  public:
   //Déclaration et Définition d'un constructeur par défaut
    Matrice(): nb_ligne(0), nb_colonne(0); matrice_(0){};


    //Déclaration d'un constructeur avec argument
    explicit Matrice (int nb_ligne=0, int nb_colonne=0); 

    //Déclaration d'un constructeur de copie
    Matrice(const Matrice& ref);

     //Déclaration d'un déstructeur
    ~Matrice();

    //Déclaration de l'opérateur =
    Matrice operator=(const Matrice &); 

    
   // Méthode d'accès à une valeur de la matrice
    int getTaille() const;
     
 
    // Méthode de modification de la taille de la matrice
    int getVal(int i, int j) const;
     
    
   
  //friend std::ostream& operator<<(std::ostream &ostr, const Matrice &m); 

  //friend std::istream& operator>>(std::istream &is, Matrice &m);
          

};
 

//Définition du constructeur avec argument
Matrice::Matrice(int nb_ligne, int nb_colonne): nb_ligne(0), nb_colonne(0), matrice_(0)
{
  //création de l'espace mémoire pour int** matrice_ de taille n
   matrice_=new int * [nb_ligne][nb_colonne];
   for(int i=0; i<nb_ligne; i++)
  {
    for(int j=0; j<nb_colonne; j++)
     matrice_[i][j]=new int [nb_ligne][nb_colonne];
  }
  //on initialise les valeurs de la matrice à 0
   for (int i=0; i<nb_ligne; i++)
    {
      for (int j=0; j<nb_colonne; j++)
       matrice_[i][j]=0;
     }
}
 




//Définition du constructeur de copie
Matrice::Matrice(const Matrice& ref): nb_ligne(ref.nb_ligne), nb_colonne(ref.nb_colonne), matrice_(nullptr)
{
    if(nb_ligne != 0 && nb_colonne !=0)
    {
        matrice_ = new int*[nb_ligne][nb_colonne];           
        for(size_t i=0; i<nb_ligne;i++)
          {
             for(size_t j=0; j<nb_colonne;j++)
               matrice_[i][j]=ref.matrice_[i][j];
          }
    }
}



//Définition du destructeur pour éviter les problèmes de fuite de mémoire
Matrice::~Matrice()
{ 
    delete[] matrice_;
    matrice_ = nullptr;
    nb_ligne = 0;
    nb_colonne=0;
}

  
//Définition de =
Matrice Matrice ::operator=(const Matrice &m)
{
    if(m.matrice_ != matrice_){ // garde contre "self assignment"
        // dealocation du *this
        delete [] matrice_;
        nb_ligne = 0;
        nb_colonne=0; 
        matrice_ = nullptr;
        if(m.nb_ligne != 0&& m.nb_colonne !=0){
            matrice_ = new int*[m.nb_ligne][nb_colonne];
            nb_ligne = m.nb_ligne;
            nb_colonne= m.nb_colonne;
           for(size_t i=0;i<nb_ligne;i++)
           {
            for(size_t j=0;i<nb_colonne;j++)
               matrice_[i][j]=m.matrice_[i][j];
           }
        }
    }
    return *this;
}




//Définition de getTaille
int Matrice::getTaille() const
{
    return nb_ligne, nb_colonne;
}
 
 
//Définition de getVal
int Matrice::getVal(int i, int j) const
{
    return matrice_[i][j];
}
  



#endif

[invite389df8bf]

Est-il possible de m'indiquer comment on écrit correctement juste le début? Je n'ai vraiment aucun exemple sur ce genre de classe.
Je vous remercie par avance.

[A voir en vidéo sur Futura]

[invite389df8bf]

Bonsoir,
voilà j'ai travaillé et je suis arrivée à ce .h

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    int nb_lig;
    int nb_col;
    double ** data;

public:
    //Constructors
   explicit matrix(int,int);
    matrix();
    matrix(const matrix &);
    ~matrix();

    //Operators
    double operator()(int i , int j );//Déclaration de l'opérateur[]
    double operator()(int i, int j) const;//Déclaration de l'opérateur[]
    matrix & operator=(matrix);
    matrix & operator*( const matrix & m1, const matrix & m2);
    void swap(matrix &);

    //Access
    int get_nb_lig() const;
    int get_nb_col() const;
    double get(int,int)const;
    void clean();




};

//Empty constructor
matrix::matrix():nb_lig(0), nb_col(0)
{
    data = nullptr;
}


//Copy constructor
matrix::matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    int i,j;
    for (int i=0;i<nb_lig;i++)
        data[i] = new double [nb_col];
    
}


//Destructor
matrix::~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}




   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 int matrix::get_nb_lig() const
{
    return nb_lig;
}

int matrix::get_nb_col() const
{
    return nb_col;
}

double matrix::get(int i,int j)const
{
    return data[i][j];
}



//Access operator ():
double matrix::operator()(int i,int j)
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}



//Access operator ():
double matrix::operator()(int i,int j) const
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}



//Assignment operator
matrix& matrix::operator = (matrix A)
{
    swap(A);
    return *this;
}


//Swap
void matrix::swap(matrix & A)
{
    std::swap(nb_lig, A.nb_lig);
    std::swap(nb_col, A.nb_col);
    std::swap(data, A.data);
}



matrix operator*( const matrix  & m1, const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
        int nb_lig1 = m1.get_nb_ligne(),
        int nb_col1 = m1.get_nb_colonne(),
        int nb_lig2 = m2.get_nb_ligne(),
        int nb_col2 = m2.get_nb_colonne();
    if(nb_col1 != nb_lig2) throw;

    matrix  m(nb_lig1,nb_col2);

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig1;i++)
      {
        for(int k=0;k<nb_col2;++k)
           {
            for(int j=0;j<nb_col1;j++)
                {
                m[i][k] += m1[i][j] * m2[j][k];
                }
           }
      }
    return m;
}

mais il me donne une erreur pour l'opérateur *, il me dit que je n'ai pas déclaré les nombre de colonne et de ligne...ect, enfin voici l'erreur
error: ‘matrix& matrix:perator*(const matrix&, const matrix&)’ must take either zero or one argument
matrix & operator*( const matrix & m1, const matrix & m2);
^
matrice.h: In function ‘matrix operator*(const matrix&, const matrix&)’:
matrice.h:131:9: error: expected unqualified-id before ‘int’
int nb_col1 = m1.get_nb_col(),
^
matrice.h:134:8: error: ‘nb_col1’ was not declared in this scope
if(nb_col1 != nb_lig2) throw;
^
matrice.h:134:19: error: ‘nb_lig2’ was not declared in this scope
if(nb_col1 != nb_lig2) throw;
^
matrice.h:136:23: error: ‘nb_col2’ was not declared in this scope
matrix m(nb_lig1,nb_col2);
^
matrice.h:143:27: error: ‘nb_col1’ was not declared in this scope
for(int j=0;j<nb_col1;j++)
^
matrice.h:145:18: error: no match for ‘operator[]’ (operand types are ‘matrix’ and ‘int’)
m[i][k] += m1[i][j] * m2[j][k];
^
matrice.h:145:30: error: no match for ‘operator[]’ (operand types are ‘const matrix’ and ‘int’)
m[i][k] += m1[i][j] * m2[j][k];
^
matrice.h:145:41: error: no match for ‘operator[]’ (operand types are ‘const matrix’ and ‘int’)
m[i][k] += m1[i][j] * m2[j][k];


Je vous prie de m'aider à corriger pour que ce programme marche et puisse calculer le produit d'une matrice et d'un vecteur.
Je vous remercie par avance.

[Jack]

La redéfinition de l'opérateur * est interne à ta classe. Un des 2 termes du produit est donc l'objet lui-même. Il n'a donc besoin que d'un seul paramètre.

[invite389df8bf]

Oui, j'ai fait une erreur. Voici le code:

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    int nb_lig;
    int nb_col;
    double ** data;

public:
    //Constructors
   explicit matrix(int,int);
    matrix();
    matrix(const matrix &);
    ~matrix();

    //Operators
    double operator()(int i , int j );//Déclaration de l'opérateur()
    double operator()(int i, int j) const;//Déclaration de l'opérateur()
    matrix & operator=(matrix);
    void swap(matrix &);
    matrix& operator*( const matrix & m2);


    //Access
    int get_nb_lig() const;
    int get_nb_col() const;
    double get(int,int)const;
    void clean();




};

//Empty constructor
matrix::matrix():nb_lig(0), nb_col(0)
{
    data = nullptr;
}


//Copy constructor
matrix::matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    int i,j;
    for (int i=0;i<nb_lig;i++)
        data[i] = new double [nb_col];
    
}


//Destructor
matrix::~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}




   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 int matrix::get_nb_lig() const
{
    return nb_lig;
}

int matrix::get_nb_col() const
{
    return nb_col;
}

double matrix::get(int i,int j)const
{
    return data[i][j];
}



//Access operator ():
double matrix::operator()(int i,int j)
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}



//Access operator ():
double matrix::operator()(int i,int j) const
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}



//Assignment operator
matrix& matrix::operator = (matrix A)
{
    swap(A);
    return *this;
}


//Swap
void matrix::swap(matrix & A)
{
    std::swap(nb_lig, A.nb_lig);
    std::swap(nb_col, A.nb_col);
    std::swap(data, A.data);
}


matrix& matrix :: operator*(const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
        int nb_lig1 = data.get_nb_lig();
        int nb_col1 = data.get_nb_col();
        int nb_lig2 = m2.get_nb_lig();
        int nb_col2 = m2.get_nb_col();
    if(nb_col1 != nb_lig2) throw;

    matrix  m(nb_lig1,nb_col2);

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig1;i++)
      {
        for(int k=0;k<nb_col2;++k)
           {
            for(int j=0;j<nb_col1;j++)
                m[i][k] +=  data[i][j] *  m2[i][k];
           }
      }
    return m;
}

Mais il continue à me renvoyer des erreurs:
In member function ‘matrix& matrix:perator*(const matrix&)’:
matrice.h:130:28: error: request for member ‘get_nb_lig’ in ‘((matrix*)this)->matrix::data’, which is of non-class type ‘double**’
int nb_lig1 = data.get_nb_lig();
^
matrice.h:131:28: error: request for member ‘get_nb_col’ in ‘((matrix*)this)->matrix::data’, which is of non-class type ‘double**’
int nb_col1 = data.get_nb_col();
^
matrice.h:144:18: error: no match for ‘operator[]’ (operand types are ‘matrix’ and ‘int’)
m[i][k] += data[i][j] * m2[i][k];
^
matrice.h:144:45: error: no match for ‘operator[]’ (operand types are ‘const matrix’ and ‘int’)
m[i][k] += data[i][j] * m2[i][k];
^
matrice.h:136:13: warning: reference to

En fait il a un souci avec l'opérateur [], or qu'on n'a pas besoin de le définir puisque c'est une matrice et que c'est plus propre d'utiliser (), et il a aussi un problème avec get, pouvez vous m'aider à corriger ce point? S'il vous plaît.
Je vous remercie par avance.

[imoca]

 int nb_lig1 = data.get_nb_lig();
        int nb_col1 = data.get_nb_col();

en

 int nb_lig1 = this->get_nb_lig();
        int nb_col1 = this->get_nb_col();

ou bien

 int nb_lig1 = nb_li;
        int nb_col1 = nb_col;

[imoca]

matrix  m(nb_lig1,nb_col2);

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig1;i++)
      {
        for(int k=0;k<nb_col2;++k)
           {
            for(int j=0;j<nb_col1;j++)
                m[i][k] +=  data[i][j] *  m2[i][k];
           }
      }
    return m;
}

Initialise la matrice à zéro.

[invite389df8bf]

S'il te plaît, pour le constructeur de copie, je l'ai refait et voici ce que j'ai fait. Peux tu me le corriger s'il te plaît

matrix::matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    int i,j;
    for (int i=0;i<nb_lig;i++)
        data[i] = new double [nb_col];
      for (int i=0;i<nb_lig;i++)
        for (int j=0;j<nb_col;j++)
    data[i][j]=A.data[i][j];
}

et pour le destucteur, j'ai fait:

matrix::~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}

il n'yaura pas de fuite de mémoire avec cette définition? Comment l'améliorer s'il vous plaît.

[invite389df8bf]

******Suite de mon précédent message*****
Quant au constructeur avec argument, je l'avais oublié dans le programme. J'ai essayé ceci (en m'inspirant d'une classe vector):

//Constructeur avec arguments
matrix::matrix(int i, int j, double val)
{
   nb_lig = i;
   nb_col=j;
   if (nb_lig == 0 && nb_col==0)
      data = nullptr; 
   else
   {
      data = new double[nb_lig][nb_col];
      for (int i=0; i<nb_lig; i++)
         for (int j=0; i<nb_col; j++)
         data[i][j] = val;
   }
}

mais il me marque les erreurs suivantes:
In constructor ‘matrix::matrix(int, int, double)’:
matrice.h:58:39: error: array size in new-expression must be constant
data = new double[nb_lig][nb_col];
^
matrice.h:58:39: error: ‘this’ is not a constant expression
matrice.cpp: In function ‘int main()’:
matrice.cpp:10:13: error: no matching function for call to ‘matrix::matrix(int, int)’
matrix a(2,2);
^
matrice.cpp:10:13: note: candidates are:
In file included from matrice.cpp:2:0:
matrice.h:69:1: note: matrix::matrix(const matrix&)
matrix::matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
^
matrice.h:69:1: note: candidate expects 1 argument, 2 provided
matrice.h:42:1: note: matrix::matrix()
matrix::matrix():nb_lig(0), nb_col(0)
^
matrice.h:42:1: note: candidate expects 0 arguments, 2 provided
matrice.h:50:1: note: matrix::matrix(int, int, double)
matrix::matrix(int i, int j, double val)
^
matrice.h:50:1: note: candidate expects 3 arguments, 2 provided
latifa@latifa-SVE1512C5E:~/Bureau$ g++ -std=c++14 matrice.cpp
In file included from matrice.cpp:2:0:
matrice.h: In constructor ‘matrix::matrix(int, int, double)’:
matrice.h:58:39: error: array size in new-expression must be constant
data = new double[nb_lig][nb_col];
^
matrice.h:58:39: error: ‘this’ is not a constant expression


Enfin, pour initialiser m, si je met m=0 avant la boucle, il ne l'accepte pas, en plus par défaut tout objet de la classe matrix est initialisé, non?
Je vous remercie par avance.

[invite389df8bf]

J"ai vérifié dans la fac, et il est dit que pour les matrices, c'est plus propre de définir l'opérateur (), et non [].

En fait, mon problème est dans le constructeur avec arguments, c'est ca. Dans la fac, ils utilisent un data avec un pointeur (contrairement à moi qu utilise deux pointeurs). Donc je n'arrive pas à débloquer. Voici mon programme avec les dérnière modification que j'ai apporté

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    int nb_lig;
    int nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(int nb_lig1,int nb_lig2);
   
  //Déclaration du constructeur de copie
    matrix(const matrix &);

   //Déclaration du destructeur
    ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double operator()(int i , int j );//Déclaration de l'opérateur()
    double operator()(int i, int j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix & operator=(matrix);
   
    //Déclaration de l'opérateur *
    matrix& operator*( const matrix & m2);


    //Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
    int get_nb_lig() const;
    int get_nb_col() const;
    int get(int,int)const;

    void clean();
};





//Définition du constructeur par défaut
matrix::matrix():nb_lig(0), nb_col(0)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
matrix::matrix(int i, int j, double val)
{
  nb_lig = i;
  nb_col=j;
   if (nb_lig == 0 || nb_col==0)
     data = nullptr; 
   else
   {
     data = new double[nb_lig][nb_col];
     for (int i=0; i<nb_lig; i++)
     for (int j=0; i<nb_col; j++)
     data[i][j] = val;
   }
}




//Définition du constructeur de copie
matrix::matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    int i,j;
    for (int i=0;i<nb_lig;i++)
        data[i] = new double [nb_col];
      for (int i=0;i<nb_lig;i++)
        for (int j=0;j<nb_col;j++)
    data[i][j]=A.data[i][j];
}


//Définition du destructeur
matrix::~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}




   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 int matrix::get_nb_lig() const
{
    return nb_lig;
}

int matrix::get_nb_col() const
{
    return nb_col;
}

int matrix::get(int i,int j)const
{
    return data[i][j];
}



//Définition de l'opérateur d'accès aux éléments ():
double matrix::operator()(int i,int j)
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}


double matrix::operator()(int i,int j) const
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}




//Définition de l'opérateur d'assignement
matrix& matrix::operator=(const matrix &A)
{
    if(A.data != data){ // garde contre "self assignment"
        // dealocation du *this
        delete [] data;
        nb_lig = 0;
        nb_col=0;
        data = nullptr;
        if(A.nb_lig != 0 || A.nb_col=0)
          {
            data = new Real[A.[nb_lig][nb_col]];
            nb_lig = A.nb_lig;
            nb_col=A.nb_col;
           for(int i=0;i<nb_lig;i++)
           for(int j=0; j<nb_col; j++)
           {
               data[i][j]=A.data[i][j];
           }
        }
    }
    return **this;
}





//Assignment operator
//matrix& matrix::operator = (matrix A)
//{
  //  swap(A);
   // return *this;
//}


//Swap
//void matrix::swap(matrix & A)
//{
  //  std::swap(nb_lig, A.nb_lig);
   // std::swap(nb_col, A.nb_col);
    //std::swap(data, A.data);
//}



//Définition de l'opérateur *
matrix& matrix :: operator*(const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
      
     /* int nb_lig1 = this.get_nb_lig();
      int nb_col1 = this.get_nb_col();
      int nb_lig2 = m2.get_nb_lig();
      int nb_col2 = m2.get_nb_col();*/
     
    if(nb_col != m2.nb_lig) throw;

    matrix m;

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig;i++)
      {
        for(int k=0;k<m2.nb_col;++k)
          {
            for(int j=0;j<nb_col;j++)
             m.data[i][k] =  data[i][j]* m2(j,k);
           }
      }
    return m;
}

et il me renvoie

error: prototype for ‘matrix::matrix(int, int, double)’ does not match any in class ‘matrix’
matrix::matrix(int i, int j, double val)
^
matrice.h:24:5: error: candidates are: matrix::matrix(const matrix&)
matrix(const matrix &);
^
matrice.h:21:13: error: matrix::matrix(int, int)
explicit matrix(int nb_lig1,int nb_lig2);
^
matrice.h:53:1: error: matrix::matrix()
matrix::matrix():nb_lig(0), nb_col(0)
^
matrice.h:143:9: error: prototype for ‘matrix& matrix:perator=(const matrix&)’ does not match any in class ‘matrix’
matrix& matrix:perator=(const matrix &A)
^
matrice.h:34:14: error: candidate is: matrix& matrix:perator=(matrix)
matrix & operator=(matrix);
^
matrice.h: In member function ‘matrix& matrix:perator*(const matrix&)’:
matrice.h:200:12: warning: reference to local variable ‘m’ returned [-Wreturn-local-addr]
matrix m;
En gros, il me demande de revoir le constructeur avec argument et d'enlever val, et il veut un changement pour l'opérateur d'assignement, plus le m de l'opérateur * qui ne lui plaît pas.

Pouvez vous m'aider à corriger le constructeur avec arguments? S'il vous plaît.

Je vous remercie par avance.

[imoca]

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    int nb_lig;
    int nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(int nb_lig1,int nb_lig2,double Val );
   
  //Déclaration du constructeur de copie
    matrix(const matrix &);

   //Déclaration du destructeur
    ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double operator()(int i , int j );//Déclaration de l'opérateur()
    double operator()(int i, int j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix & operator=(matrix);
   
    //Déclaration de l'opérateur *
    matrix& operator*( const matrix & m2);


    //Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
    int get_nb_lig() const;
    int get_nb_col() const;
    int get(int,int)const;

    void clean();
};





//Définition du constructeur par défaut
matrix::matrix():nb_lig(0), nb_col(0)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
matrix::matrix(int i, int j, double val)
{
  nb_lig = i;
  nb_col=j;
   if (nb_lig == 0 || nb_col==0)
     data = nullptr; 
   else
   {
     data = new double[nb_lig][nb_col];
     for (int i=0; i<nb_lig; i++)
     for (int j=0; i<nb_col; j++)
     data[i][j] = val;
   }
}




//Définition du constructeur de copie
matrix::matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    int i,j;
    for (int i=0;i<nb_lig;i++)
        data[i] = new double [nb_col];
      for (int i=0;i<nb_lig;i++)
        for (int j=0;j<nb_col;j++)
    data[i][j]=A.data[i][j];
}


//Définition du destructeur
matrix::~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}




   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 int matrix::get_nb_lig() const
{
    return nb_lig;
}

int matrix::get_nb_col() const
{
    return nb_col;
}

int matrix::get(int i,int j)const
{
    return data[i][j];
}



//Définition de l'opérateur d'accès aux éléments ():
double matrix::operator()(int i,int j)
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}


double matrix::operator()(int i,int j) const
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[i][j];
}




//Définition de l'opérateur d'assignement
matrix& matrix::operator=(const matrix &A)
{
    if(A.data != data){ // garde contre "self assignment"
        // dealocation du *this
        delete [] data;
        nb_lig = 0;
        nb_col=0;
        data = nullptr;
        if(A.nb_lig != 0 || A.nb_col=0)
          {
            data = new Real[A.[nb_lig][nb_col]];
            nb_lig = A.nb_lig;
            nb_col=A.nb_col;
           for(int i=0;i<nb_lig;i++)
           for(int j=0; j<nb_col; j++)
           {
               data[i][j]=A.data[i][j];
           }
        }
    }
    return **this;
}





//Assignment operator
//matrix& matrix::operator = (matrix A)
//{
  //  swap(A);
   // return *this;
//}


//Swap
//void matrix::swap(matrix & A)
//{
  //  std::swap(nb_lig, A.nb_lig);
   // std::swap(nb_col, A.nb_col);
    //std::swap(data, A.data);
//}



//Définition de l'opérateur *
matrix& matrix :: operator*(const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
      
     /* int nb_lig1 = this.get_nb_lig();
      int nb_col1 = this.get_nb_col();
      int nb_lig2 = m2.get_nb_lig();
      int nb_col2 = m2.get_nb_col();*/
     
    if(nb_col != m2.nb_lig) throw;

    matrix m;

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig;i++)
      {
        for(int k=0;k<m2.nb_col;++k)
          {
            for(int j=0;j<nb_col;j++)
             m.data[i][k] =  data[i][j]* m2(j,k);
           }
      }
    return m;
}

[invite389df8bf]

Merci Imoca, en fait j'avais oublié le val dans la déclaration. En attendant, j'ai recorrigé quelques trucs, et voici la dérnière version du programme

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    int nb_lig;
    int nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(int i,int j, double val);
   
  //Déclaration du constructeur de copie
    matrix(const matrix &);

   //Déclaration du destructeur
    ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double operator()(int i , int j );//Déclaration de l'opérateur()
    double operator()(int i, int j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix & operator=(matrix);
   
    //Déclaration de l'opérateur *
    matrix& operator*( const matrix & m2);


    //Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
    int get_nb_lig() const;
    int get_nb_col() const;
    int get(int,int)const;

    void clean();
};





//Définition du constructeur par défaut
matrix :: matrix() :  nb_lig(0), nb_col(0)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
matrix :: matrix(int i, int j, double val)
{
  nb_lig = i;
  nb_col=j;
   if (nb_lig == 0 || nb_col==0)
     data = nullptr; 
   else
   {
     data = new double[nb_lig][nb_col];
     for (int i=0; i<nb_lig; i++)
     for (int j=0; i<nb_col; j++)
     data[ i][ j] = val;
   }
}




//Définition du constructeur de copie
matrix : : matrix(const matrix &A) : nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[ nb_lig];
    int i,j;
    for (int i=0;i<nb_lig; i++)
        data[ i] = new double [ nb_col];
      for (int i=0;i<nb_lig; i++)
        for (int j=0;j<nb_col; j++)
    data[ i][  j]=A.data[ i][ j ];
}


//Définition du destructeur
matrix : : ~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}




   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 int matrix : : get_nb_lig() const
{
    return nb_lig;
}

int matrix : : get_nb_col() const
{
    return nb_col;
}

int matrix : :   get(int i,int j)const
{
    return data[ i][ j];
}



//Définition de l'opérateur d'accès aux éléments ():
double matrix : : operator()(int i,int j)
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[ i][ j];
}


double matrix : : operator()(int i,int j) const
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[ i][ j];
}




//Définition de l'opérateur d'assignement
matrix& matrix : : operator=(const matrix &A)
{
    if(A.data != data){ // garde contre "self assignment"
        // dealocation du *this
        delete [] data;
        nb_lig = 0;
        nb_col=0;
        data = nullptr;
        if(A.nb_lig != 0 || A.nb_col=0)
          {
            data = new Real[A.[nb_lig][nb_col]];
            nb_lig = A.nb_lig;
            nb_col=A.nb_col;
           for(int i=0;i<nb_lig;i++)
           for(int j=0; j<nb_col; j++)
           {
               data[ i][  j]=A.data[ i][ j];
           }
        }
    }
    return **this;
}





//Assignment operator
//matrix& matrix : : operator = (matrix A)
//{
  //  swap(A);
   // return *this;
//}


//Swap
//void matrix : : swap(matrix & A)
//{
  //  std : : swap(nb_lig, A.nb_lig);
   // std : : swap(nb_col, A.nb_col);
    //std : : swap(data, A.data);
//}



//Définition de l'opérateur *
matrix& matrix : : operator*(const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
      
     /* int nb_lig1 = this.get_nb_lig();
      int nb_col1 = this.get_nb_col();
      int nb_lig2 = m2.get_nb_lig();
      int nb_col2 = m2.get_nb_col();*/
     
    if(nb_col != m2.nb_lig) throw;

    matrix m;

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig;i++)
      {
        for(int k=0;k<m2.nb_col;++k)
          {
            for(int j=0;j<nb_col;j++)
             m.data[ i][ k] =  data[ i][ j]* m2(j,k);
           }
      }
    return m;
}

Il me donne les erreurs suivantes:

In constructor ‘matrix : : matrix(int, int, double)’:
matrice.h:69:38: error: array size in new-expression must be constant
data = new double[nb_lig][nb_col];
^
matrice.h:69:38: error: ‘this’ is not a constant expression
matrice.h: At global scope:
matrice.h:143:9: error: prototype for ‘matrix& matrix : : operator=(const matrix&)’ does not match any in class ‘matrix’
matrix& matrix : : operator=(const matrix &A)
^
matrice.h:34:14: error : candidate is: matrix& matrix : : operator=(matrix)
matrix & operator=(matrix);
^
matrice.h: In member function ‘matrix& matrix : : operator*(const matrix&)’:
matrice.h:200:12 : warning: reference to local variable ‘m’ returned [-Wreturn-local-addr]
matrix m;


Dans la fac, j'ai lu des exemples pour définir les constructeurs, mais ils utilisaient un seul pointeur, du coup je suis perdue avec deux pointeurs. Aidez moi s'il vous plaît à corriger ces erreurs. Je vous remercie par avance.

[invite389df8bf]

Oui, en fait j'ai fait une boucle pour allouer les lignes puis les colonnes. Voici la dérnière version du programme

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    int nb_lig;
    int nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(int i,int j);
   
  //Déclaration du constructeur de copie
    matrix(const matrix &);

   //Déclaration du destructeur
    ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double &operator()(int i , int j );//Déclaration de l'opérateur()
    double operator()(int i, int j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix& operator=(const matrix &A);
   
    //Déclaration de l'opérateur *
    matrix& operator*( const matrix & m2);


    //Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
    int get_nb_lig() const;
    int get_nb_col() const;
    int get(int,int)const;

    void clean();
};





//Définition du constructeur par défaut
matrix : : matrix() : nb_lig(0), nb_col(0)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
matrix : : matrix(int i, int j)
{
  nb_lig = i;
  nb_col=j;
   if (nb_lig == 0 || nb_col==0)
     data = nullptr; 
   else
   {
      
      data = new double *[nb_lig];
    for (int k=0;k<nb_lig;k++)
        data[k] = new double [nb_col];
    
   }
}




//Définition du constructeur de copie
matrix : : matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    int i,j;
    for (int i=0;i<nb_lig;i++)
        data[ i] = new double [nb_col];
      for (int i=0;i<nb_lig;i++)
        for (int j=0;j<nb_col;j++)
    data[ i][j]=A.data [ i][j];
}


//Définition du destructeur
matrix : : ~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}




   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 int matrix : : get_nb_lig() const
{
    return nb_lig;
}

int matrix : : get_nb_col() const
{
    return nb_col;
}

int matrix : : get(int i,int j)const
{
    return data[ i][ j];
}



//Définition de l'opérateur d'accès aux éléments ():
double &matrix :: operator()(int i,int j)
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[ i][ j];
}


double matrix :: operator()(int i,int j) const
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[ i][ j];
}




//Définition de l'opérateur d'assignement
matrix& matrix :: operator=(const matrix &A)
{
   

        if(A.nb_lig != 0 || A.nb_col !=0)
          {
           data = new double *[A.nb_lig];
             for (int k=0;k<nb_lig;k++)
             data[k] = new double [A.nb_col];
           
            nb_lig = A.nb_lig;
            nb_col=A.nb_col;
           for(int i=0;i<nb_lig;i++)
           for(int j=0; j<nb_col; j++)
           {
               data[ i][j]=A.data[ i][j];
           }
        
    }
    return *this;
}





//Assignment operator
//matrix& matrix :: operator = (matrix A)
//{
  //  swap(A);
   // return *this;
//}


//Swap
//void matrix :: swap(matrix & A)
//{
  //  std :: swap(nb_lig, A.nb_lig);
   // std :: swap(nb_col, A.nb_col);
    //std :: swap(data, A.data);
//}



//Définition de l'opérateur *
matrix& matrix :: operator*(const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
      
     /* int nb_lig1 = this.get_nb_lig();
      int nb_col1 = this.get_nb_col();
      int nb_lig2 = m2.get_nb_lig();
      int nb_col2 = m2.get_nb_col();*/
     
    if(nb_col != m2.nb_lig) 
{
std::cout<< "error dimension"<<std::endl;	
throw;
}
    matrix m(nb_lig,m2.nb_col);

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig;i++)
      {
        for(int k=0;k<m2.nb_col;++k)
          {
            for(int j=0;j<nb_col;j++)
             m(i,k) +=  data(i,j)* m2(j,k);
           }
      }
    return m;
}

et il me renvoie toujours cette erreur: (qui concerne l'opérateur produit)
In member function ‘matrix& matrix :: operator*(const matrix&)’:
matrice.h:211:33: error: expression cannot be used as a function
m(i,k) += data(i,j)* m2(j,k);
^
matrice.h:203:12: warning: reference to local variable ‘m’ returned [-Wreturn-local-addr]
matrix m(nb_lig,m2.nb_col);

Je n'arrive pas à m'en débarasser. Comment régler ça s'il vous plaît? Je vous remercie par avance pour votre aide.

[imoca]

m(i,k) += data(i,j)* m2(j,k);

data n'est pas un matrix.
Essai:

m(i,k) += this(i,j)* m2(j,k);

[invite389df8bf]

Il me renvoie ceci:
In member function ‘matrix& matrix :: operator*(const matrix&)’:
matrice.h:211:32: error: expression cannot be used as a function
m(i,k) += this(i,j)* m2(j,k);
^
matrice.h:203:12: warning: reference to local variable ‘m’ returned [-Wreturn-local-addr]
matrix m(nb_lig,m2.nb_col);


Mon code avec ce changement est:

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    int nb_lig;
    int nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(int i,int j);
   
  //Déclaration du constructeur de copie
    matrix(const matrix &);

   //Déclaration du destructeur
    ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double &operator()(int i , int j );//Déclaration de l'opérateur()
    double operator()(int i, int j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix& operator=(const matrix &A);
   
    //Déclaration de l'opérateur *
    matrix& operator*( const matrix & m2);


    //Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
    int get_nb_lig() const;
    int get_nb_col() const;
    int get(int,int)const;

    void clean();
};





//Définition du constructeur par défaut
matrix :: matrix():nb_lig(0), nb_col(0)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
matrix :: matrix(int i, int j)
{
  nb_lig = i;
  nb_col=j;
   if (nb_lig == 0 || nb_col==0)
     data = nullptr; 
   else
   {
      
      data = new double *[nb_lig];
    for (int k=0;k<nb_lig;k++)
        data[k] = new double [nb_col];
    
   }
}




//Définition du constructeur de copie
matrix :: matrix(const matrix &A):nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    int i,j;
    for (int i=0;i<nb_lig;i++)
        data[ i] = new double [nb_col];
      for (int i=0;i<nb_lig;i++)
        for (int j=0;j<nb_col;j++)
    data[ i][ j]=A.data[ i][ j];
}


//Définition du destructeur
matrix :: ~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}




   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 int matrix :: get_nb_lig() const
{
    return nb_lig;
}

int matrix :: get_nb_col() const
{
    return nb_col;
}

int matrix :: get(int i,int j)const
{
    return data[ i ][ j];
}



//Définition de l'opérateur d'accès aux éléments ():
double &matrix :: operator()(int i,int j)
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[ i][ j];
}


double matrix :: operator()(int i,int j) const
{
    assert(i >= 0 && i < nb_lig);
    assert(j >= 0 && j < nb_col);
    return data[ i][ j];
}




//Définition de l'opérateur d'assignement
matrix& matrix :: operator=(const matrix &A)
{
   

        if(A.nb_lig != 0 || A.nb_col !=0)
          {
           data = new double *[A.nb_lig];
             for (int k=0;k<nb_lig;k++)
             data[k] = new double [A.nb_col];
           
            nb_lig = A.nb_lig;
            nb_col=A.nb_col;
           for(int i=0;i<nb_lig;i++)
           for(int j=0; j<nb_col; j++)
           {
               data[ i][ j]=A.data[ i][ j];
           }
        
    }
    return *this;
}





//Assignment operator
//matrix& matrix :: operator = (matrix A)
//{
  //  swap(A);
   // return *this;
//}


//Swap
//void matrix :: swap(matrix & A)
//{
  //  std :: swap(nb_lig, A.nb_lig);
   // std :: swap(nb_col, A.nb_col);
    //std :: swap(data, A.data);
//}



//Définition de l'opérateur *
matrix& matrix :: operator*(const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
      
     /* int nb_lig1 = this.get_nb_lig();
      int nb_col1 = this.get_nb_col();
      int nb_lig2 = m2.get_nb_lig();
      int nb_col2 = m2.get_nb_col();*/
     
    if(nb_col != m2.nb_lig) 
{
std :: cout<< "error dimension"<<std::endl;	
throw;
}
    matrix m(nb_lig,m2.nb_col);

    // Aik = sum_j(Bij * Cjk)
    for(int i=0;i<nb_lig;i++)
      {
        for(int k=0;k<m2.nb_col;++k)
          {
            for(int j=0;j<nb_col;j++)
             m(i,k) += this(i,j)* m2(j,k);
           }
      }
    return m;
}

Je vous remercie beaucoup par avance.

[imoca]

m(i,k) += this(i,j)* m2(j,k);

l'opérateur () accède a la valeur mais permet-il l'affectation?

Essai:

m.setVal(i,k,m(i,k)+ this(i,j)* m2(j,k));

avec

void matrix::setVal(int a,int b,double c){
       this->data[i][j]=c;
}

[invite389df8bf]

Il me renvoie ceci

In member function ‘void matrix::setVal(int, int, double)’:
matrice.h:129:19: error: ‘i’ was not declared in this scope
this->data[i][j]=c;
^
matrice.h:129:22: error: ‘j’ was not declared in this scope
this->data[i][j]=c;
^
matrice.h: In member function ‘matrix& matrix:perator*(const matrix&)’:
matrice.h:222:43: error: expression cannot be used as a function
m.setVal(i,k,m(i,k)+ this(i,j)* m2(j,k));
^
matrice.h:214:12: warning: reference to local variable ‘m’ returned [-Wreturn-local-addr]
matrix m(nb_lig,m2.nb_col);


Je vous remercie par avance pour votre aide.

[invite389df8bf]

Bonjour,

j'ai continué à travaillé sur le programme, et il n'y a plus d'erreur d'après mon compilateur, seule problème c'est que dans le main, quand je lui demande de faire le produit d'une matrice est d'un vecteur, il me signale ""Erreur de segmentation (core dumped)"". Je n'arrive pas à voir où est l'erreur. Merci de m'aider à repérer le problème et à le réparer. Voici le .h et le .cpp


.h

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include  <cassert>  // assert()


class matrix
{
private:
    std :: size_t nb_lig;
    std :: size_t nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(std :: size_t i,std :: size_t j);
   
  //Déclaration du constructeur de copie
    matrix(const matrix &);

   //Déclaration du destructeur
    ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double &operator()(std :: size_t i , std :: size_t j );//Déclaration de l'opérateur()
    double operator()(std :: size_t i, std :: size_t j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix& operator=(const matrix &A);
   
    //Déclaration de l'opérateur *
    matrix& operator*( const matrix & m2);


    //Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
    std ::  size_t get_nb_lig() const;
    std :: size_t get_nb_col() const;
    std :: size_t get(std :: size_t,std :: size_t)const;

    void clean();
};



//Définition du constructeur par défaut
matrix :: matrix() : nb_lig(0), nb_col(0)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
matrix :: matrix(std :: size_t i, std :: size_t j)
{
  nb_lig = i;
  nb_col=j;
   if (nb_lig == 0 || nb_col==0)
     data = nullptr; 
   else
   {
      
      data = new double *[nb_lig];
    for (std :: size_t k=0;k<nb_lig;k++)
        data[ k ] = new double [nb_col];
    
   }
}



//Définition du constructeur de copie
matrix :: matrix(const matrix &A) : nb_lig(A.nb_lig), nb_col(A.nb_col)
{
    data = new double *[nb_lig];
    std :: size_t i,j;
    for (std :: size_t i=0;i<nb_lig;i++)
        data[ i ] = new double [nb_col];
      for (std :: size_t i=0;i<nb_lig;i++)
        for (std :: size_t j=0;j<nb_col;j++)
    data [ i][ j]=A.data[ i][ j];
}


//Définition du destructeur
matrix :: ~matrix()
{
    delete[] data;
    data = nullptr;
    nb_lig = 0;
    nb_col=0;
}


   
//Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice
 std :: size_t matrix :: get_nb_lig() const
{
    return nb_lig;
}

std::size_t matrix :: get_nb_col() const
{
    return nb_col;
}

std :: size_t matrix :: get(std : : size_t i,std :: size_t j)const
{
    return data[ i][ j];
}



//Définition de l'opérateur d'accès aux éléments ():
double &matrix :: operator()(std :: size_t i,std :: size_t j)
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[  i ][  j ];
}


double matrix :: operator()(std :: size_t i,std :: size_t j) const
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[ i ][ j ] ;
}



//Définition de l'opérateur d'assignement
matrix& matrix :: operator=(const matrix &A)
{
   

        if(A.nb_lig != 0 || A.nb_col !=0)
          {
           data = new double *[A.nb_lig];
             for (std :: size_t k=0;k<nb_lig;k++)
             data[ k] = new double [A.nb_col];
           
            nb_lig = A.nb_lig;
            nb_col=A.nb_col;
           for(std :: size_t i=0;i<nb_lig;i++)
           for(std :: size_t j=0; j<nb_col; j++)
           {
               data[ i ] [ j ]=A.data[ i ][ j ];
           }
        
    }
    return *this;
}



//Définition de l'opérateur *
matrix& matrix :: operator*(const matrix & m2)
{
    // vérifier que les deux matrices peuvent être multipliées
     
    if(nb_col != m2.nb_lig) 
{
std :: cout<< "error dimension"<<std::endl;	
throw;
}
    matrix m;

    // Aik = sum_j(Bij * Cjk)
    for(std :: size_t i=0;i<nb_lig;i++)
      {
        for(std :: size_t k=0;k<m2.nb_col;++k)
          {
            for(std::size_t j=0;j<nb_col;j++)
             m.data[ i ][ k ] += data[ i][ j ]* m2( j, k);
           }
      }
    return *this;
}

le .cpp

#include <iostream>
#include "matrice.h"
#include <cmath>
#include <fstream>
using namespace std;


int main()
 {

 matrix M(2,2);
 matrix V(2,1) ;
M(0,0)=1;
M(0,1)=2;
M(1,0)=1;
M(1,1)=2;



V(0,0)=1;
V(1,0)=2;


 
matrix prod(2,1);
prod= M*V;

 }

Je vous remercie par avance pour votre aide.

[imoca]

Petite coquille, essai plutot

void matrix::setVal(int i,int j,double c){
       this->data[i][j]=c;
}

[invite389df8bf]

Excuses moi s'il te plaît, j'ai essayé pleins de trucs et à chaque fois je supprime et je refait, et donc je suis perdue (j'avais perdu les définition de get et set, et maintenant il me donne une erreur
Peux tu m'aider s'il te plaît, voici mon code

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    std::size_t nb_lig;
    std::size_t nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(std::size_t nb_lig,std::size_t nb_col);
   
  //Déclaration du constructeur de copie
   matrix(const matrix &);

   //Déclaration du destructeur
     ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double &operator()(std::size_t i , std::size_t j );//Déclaration de l'opérateur()
    double operator()(std::size_t i, std::size_t j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix& operator=(const matrix &A);
   
    //Déclaration de l'opérateur *
   // matrix& operator*( const matrix & m2);

   void swap(matrix & other){
        std::swap(nb_lig, other.nb_lig);
        std::swap(nb_col, other.nb_col);
        std::swap(data, other.data);
    }
   
   //Déclaration de la fonction Setline
    void set(const std::size_t & i, const std::size_t & j, const Real & x);

  //Déclaration de la fonction get
    std::size_t get_nb_lig() const;
    std::size_t get_nb_col() const;

};






//Définition du constructeur par défaut
matrix::matrix():nb_lig(1), nb_col(1)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
 matrix::matrix(std::size_t nb_lig=1,std::size_t nb_col=1):
  nb_lig(nb_lig), 
  nb_col(nb_col),
  data(nullptr)
{
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)
      data[i]=new double [nb_col];
  } catch(std::bad_alloc const& ba){
    if(data){
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
    }
    delete[] data;
    throw;
  }
}


//Définition du constructeur de copie
 matrix::matrix(const matrix &A):
  nb_lig(A.nb_lig), //initialisation du nombre de lignes
  nb_col(A.nb_col),  //initialisation du nombre de colonnes
  data(nullptr)      //initialisation de data à zéro
 {
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)   //allocation de l'espace où l'on va copier
      data[i]=new double [nb_col];
      } 
   catch(std::bad_alloc const& ba)
     {         
    if(data)
       {
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
       }
    delete[] data;
    throw;
     }
   for (std::size_t i=0; i<nb_lig; i++)    //on copie la matrice A élément par élément
    for (std::size_t j=0; j<nb_col; j++)
     data[i][j]= A.data[i][j];
 }




//Définition du destructeur
matrix::~matrix()
{
  if(data){
    delete[] data;
    data = nullptr;
    }

    nb_lig = 0;
    nb_col=0;
}


   



//Définition de l'opérateur d'accès aux éléments ():
double &matrix::operator()(std::size_t i,std::size_t j)
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}


double matrix::operator()(std::size_t i,std::size_t j) const
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}



matrix& matrix::operator = (matrix const & A)
{
    
    matrix copy(A);//on crée une copie de A 
    swap(copy);///* on interverti les données de copy et de this */
    return  * this;
}



   //Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice

         std::size_t::matrix get_nb_lig() const
        {
            return nb_lig;
        }



       std::size_t::matrix get_nb_col() const
        {
            return nb_col;
        }



  //Méthode setTaille pour modifier la taille de la matrice           

       void set(const std::size_t & i, const std::size_t & j, const Real & x)
        {
            if(i >= get_nb_lig()) throw;
            if(j >= get_nb_col()) throw;
            data[i][j] = x;
        }





//Définition de l'opérateur *
//matrix& matrix :: operator*(const matrix & m2)
//{
    //vérifier que les deux matrices peuvent être multipliées
     
  //  if(nb_col != m2.nb_lig) 
//{
//std::cout<< "error dimension"<<std::endl;	
//throw;
//}
  // matrix m(nb_lig,m2.nb_col);
    // for (std::size_t i=0; i<nb_lig; i++)
    // for (std::size_t j=0; j<m2.nb_col;j++)
     // m(i,j)=0;

     //Aik = sum_j(Bij * Cjk)
    //for(std::size_t i=0;i<nb_lig;i++)
      //{
       //for(std::size_t k=0;k<m2.nb_col;++k)
         // {
           // for(std::size_t j=0;j<nb_col;j++)
            // m.data[ i][k] += data[ i][ j]* m2( j, k);
           //}
      //}
   // return m;
//}

[imoca]

//Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
    int get_nb_lig() const;
    int get_nb_col() const;
    int get(int,int)const;

[invite389df8bf]

Oh pardon, voici le code et il me remet des erreurs sur get, on est obligé d'utilisé get pour avoir le produit? Merci de m'aider à corriger le problème.

    #include <iostream>
    #include <cmath>
    #include <iomanip>  // setprecision()
    #include <cassert>  // assert()


    class matrix
    {
    private:
        std::size_t nb_lig;
        std::size_t nb_col;
        double ** data;

    public:

         //Déclaration du constructeur par défaut
         matrix();

        //Déclaration du constructeur avec arguments
       explicit matrix(std::size_t nb_lig,std::size_t nb_col);
       
      //Déclaration du constructeur de copie
       matrix(const matrix &);

       //Déclaration du destructeur
         ~matrix();

        //Déclaration de l'opérateur () d'accès aux éléments
        double &operator()(std::size_t i , std::size_t j );//Déclaration de l'opérateur()
        double operator()(std::size_t i, std::size_t j) const;//Déclaration de l'opérateur()

        //Déclaration de l'opérateur d'assignement
        matrix& operator=(const matrix &A);
       
        //Déclaration de l'opérateur *
       // matrix& operator*( const matrix & m2);

       void swap(matrix & other){
            std::swap(nb_lig, other.nb_lig);
            std::swap(nb_col, other.nb_col);
            std::swap(data, other.data);
        }
       
       //Déclaration de la fonction Setline
        void set(const std::size_t & i, const std::size_t & j, const double & x);

      //Déclarations d'opérateurs d'accés au nombre de lignes, et nombre de colonnes
       int get_nb_lig() const;
       int get_nb_col() const;
       int get(int,int)const;

    };






    //Définition du constructeur par défaut
    matrix::matrix():nb_lig(1), nb_col(1)
    {
        data = nullptr;
    }



    //Définition du constructeur avec arguments
     matrix::matrix(std::size_t nb_lig=1,std::size_t nb_col=1):
      nb_lig(nb_lig), 
      nb_col(nb_col),
      data(nullptr)
    {
      try{
        data=new double*[nb_lig];
        for (std::size_t i=0; i<nb_lig; i++)
          data[i]=new double [nb_col];
      } catch(std::bad_alloc const& ba){
        if(data){
          for (std::size_t i=0; i<nb_lig; i++)
            delete[] data[i];
        }
        delete[] data;
        throw;
      }
    }


    //Définition du constructeur de copie
     matrix::matrix(const matrix &A):
      nb_lig(A.nb_lig), //initialisation du nombre de lignes
      nb_col(A.nb_col),  //initialisation du nombre de colonnes
      data(nullptr)      //initialisation de data à zéro
     {
      try{
        data=new double*[nb_lig];
        for (std::size_t i=0; i<nb_lig; i++)   //allocation de l'espace où l'on va copier
          data[i]=new double [nb_col];
          } 
       catch(std::bad_alloc const& ba)
         {         
        if(data)
           {
          for (std::size_t i=0; i<nb_lig; i++)
            delete[] data[i];
           }
        delete[] data;
        throw;
         }
       for (std::size_t i=0; i<nb_lig; i++)    //on copie la matrice A élément par élément
        for (std::size_t j=0; j<nb_col; j++)
         data[i][j]= A.data[i][j];
     }




    //Définition du destructeur
    matrix::~matrix()
    {
      if(data){
        delete[] data;
        data = nullptr;
        }

        nb_lig = 0;
        nb_col=0;
    }


       



    //Définition de l'opérateur d'accès aux éléments ():
    double &matrix::operator()(std::size_t i,std::size_t j)
    {
        assert(i >= 0 && i <= nb_lig);
        assert(j >= 0 && j <= nb_col);
        return data[i][j];
    }


    double matrix::operator()(std::size_t i,std::size_t j) const
    {
        assert(i >= 0 && i <= nb_lig);
        assert(j >= 0 && j <= nb_col);
        return data[i][j];
    }



    matrix& matrix::operator = (matrix const & A)
    {
        
        matrix copy(A);//on crée une copie de A 
        swap(copy);///* on interverti les données de copy et de this */
        return  * this;
    }



       //Méthodes get pour retourner le nombre de lignes et le nombre de colonne d'une matrice

             std::size_t::matrix get_nb_lig() const
            {
                return nb_lig;
            }



           std::size_t::matrix get_nb_col() const
            {
                return nb_col;
            }



      //Méthode setTaille pour modifier la taille de la matrice           

           void set(const std::size_t & i, const std::size_t & j, const double & x)
            {
                if(i >= get_nb_lig()) throw;
                if(j >= get_nb_col()) throw;
                data[i][j] = x;
            }





    //Définition de l'opérateur *
    //matrix& matrix :: operator*(const matrix & m2)
    //{
        //vérifier que les deux matrices peuvent être multipliées
         
      //  if(nb_col != m2.nb_lig) 
    //{
    //std::cout<< "error dimension"<<std::endl;	
    //throw;
    //}
      // matrix m(nb_lig,m2.nb_col);
        // for (std::size_t i=0; i<nb_lig; i++)
        // for (std::size_t j=0; j<m2.nb_col;j++)
         // m(i,j)=0;

         //Aik = sum_j(Bij * Cjk)
        //for(std::size_t i=0;i<nb_lig;i++)
          //{
           //for(std::size_t k=0;k<m2.nb_col;++k)
             // {
               // for(std::size_t j=0;j<nb_col;j++)
                // m.data[ i][k] += data[ i][ j]* m2( j, k);
               //}
          //}
       // return m;
    //}

les erreurs sont
In file included from matrice.cpp:2:0:
matrice.h:164:34: error: expected initializer before ‘get_nb_lig’
std::size_t::matrix get_nb_lig() const
^
matrice.h:171:32: error: expected initializer before ‘get_nb_col’
std::size_t::matrix get_nb_col() const
^
matrice.h: In function ‘void set(const size_t&, const size_t&, const double&)’:
matrice.h:182:36: error: ‘get_nb_lig’ was not declared in this scope
if(i >= get_nb_lig()) throw;
^
matrice.h:183:36: error: ‘get_nb_col’ was not declared in this scope
if(j >= get_nb_col()) throw;
^
matrice.h:184:17: error: ‘data’ was not declared in this scope
data[i][j] = x;

[invite389df8bf]

En fait c'est bon, il fallait changer la signature de l'opérateur *.
Maintenant ca marche, et voici le code

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    std::size_t nb_lig;
    std::size_t nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(std::size_t nb_lig,std::size_t nb_col);
   
  //Déclaration du constructeur de copie
   matrix(const matrix &);

   //Déclaration du destructeur
     ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double &operator()(std::size_t i , std::size_t j );//Déclaration de l'opérateur()
    double operator()(std::size_t i, std::size_t j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix& operator=(const matrix &A);
   

   void swap(matrix & other){
        std::swap(nb_lig, other.nb_lig);
        std::swap(nb_col, other.nb_col);
        std::swap(data, other.data);
    }
   

    //Déclaration de l'opérateur *
     matrix operator*( const matrix & m2);

 
};






//Définition du constructeur par défaut
matrix::matrix():nb_lig(1), nb_col(1)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
 matrix::matrix(std::size_t nb_lig=1,std::size_t nb_col=1):
  nb_lig(nb_lig), 
  nb_col(nb_col),
  data(nullptr)
{
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)
      data[i]=new double [nb_col];
  } catch(std::bad_alloc const& ba){
    if(data){
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
    }
    delete[] data;
    throw;
  }
}


//Définition du constructeur de copie
 matrix::matrix(const matrix &A):
  nb_lig(A.nb_lig), //initialisation du nombre de lignes
  nb_col(A.nb_col),  //initialisation du nombre de colonnes
  data(nullptr)      //initialisation de data à zéro
 {
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)   //allocation de l'espace où l'on va copier
      data[i]=new double [nb_col];
      } 
   catch(std::bad_alloc const& ba)
     {         
    if(data)
       {
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
       }
    delete[] data;
    throw;
     }
   for (std::size_t i=0; i<nb_lig; i++)    //on copie la matrice A élément par élément
    for (std::size_t j=0; j<nb_col; j++)
     data[i][j]= A.data[i][j];
 }




//Définition du destructeur
matrix::~matrix()
{
  if(data){
    delete[] data;
    data = nullptr;
    }

    nb_lig = 0;
    nb_col=0;
}


   



//Définition de l'opérateur d'accès aux éléments ():
double &matrix::operator()(std::size_t i,std::size_t j)
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}


double matrix::operator()(std::size_t i,std::size_t j) const
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}


//Définition de l'opérateur d'assignation

matrix& matrix::operator = (matrix const & A)
{
    
    matrix copy(A);//on crée une copie de A 
    swap(copy);///* on interverti les données de copy et de this */
    return  * this;
}










//Définition de l'opérateur *
matrix matrix :: operator*(const matrix & m2)
{
    //vérifier que les deux matrices peuvent être multipliées
     
   if(nb_col != m2.nb_lig) 
{
std::cout<< "error dimension"<<std::endl;	
throw;
}
   matrix m(nb_lig,m2.nb_col);
    

     //Aik = sum_j(Bij * Cjk)
    for(std::size_t i=0;i<nb_lig;i++)
      {
       for(std::size_t k=0;k<m2.nb_col;++k)
         {
            for(std::size_t j=0;j<nb_col;j++)
             m.data[ i][k] += data[ i][ j]* m2( j, k);
           }
      }
   return m;
}

et voici le .cpp

#include <iostream>
#include "matrice.h"
#include <cmath>
#include <fstream>
using namespace std;


int main()
 {

 matrix M(2,2);
 matrix V(2,1) ;
M(0,0)=1;
M(0,1)=2;
M(1,0)=1;
M(1,1)=2;



V(0,0)=1;
V(1,0)=2;


 
matrix prod(2,1);
prod= M*V;

 }

Comment afficher la matrice prod s'il vous plaît? cout ne marche pas, et j'ai lu qu'il y'a ostream mais je n'ai réussi à l'implémenter (sans les fonctions set et get svp)
Je vous remercie par avance pour votre aide.

[imoca]

void Matrix::afficherMatrice(){
    int nb_ligne=this->nb_lig;
    int nb_colonne=this->nb_col
    for(int i=0;i<nb_ligne;i++){
        for(int j=0;j<nb_colonne;j++){
            cout<< this->data[i][j]<<" ";
        }
        cout<<endl;
    }
}

[invite389df8bf]

En fait, voici mon code, il a l'air de fonctionner, mais il me donne un faux résultat, je n'arrive pas à voir où est le problème. Peux tu m'aider s'il te plaît

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()


class matrix
{
private:
    std::size_t nb_lig;
    std::size_t nb_col;
    double ** data;

public:

     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
   explicit matrix(std::size_t nb_lig,std::size_t nb_col);
   
  //Déclaration du constructeur de copie
   matrix(const matrix &);

   //Déclaration du destructeur
     ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double&  operator()(std::size_t i , std::size_t j );//Déclaration de l'opérateur()
    double operator()(std::size_t i, std::size_t j) const;//Déclaration de l'opérateur()

    //Déclaration de l'opérateur d'assignement
    matrix& operator=(const matrix &A);
   

   void swap(matrix & other){
        std::swap(nb_lig, other.nb_lig);
        std::swap(nb_col, other.nb_col);
        std::swap(data, other.data);
    }
   

    //Déclaration de l'opérateur *
     matrix operator*( const matrix & m2);

 
};






//Définition du constructeur par défaut
matrix::matrix():nb_lig(1), nb_col(1)
{
    data = nullptr;
}



//Définition du constructeur avec arguments
 matrix::matrix(std::size_t nb_lig=1,std::size_t nb_col=1):
  nb_lig(nb_lig), 
  nb_col(nb_col),
  data(nullptr)
{
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)
      data[i]=new double [nb_col];
  } catch(std::bad_alloc const& ba){
    if(data){
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
    }
    delete[] data;
    throw;
  }
}


//Définition du constructeur de copie
 matrix::matrix(const matrix &A):
  nb_lig(A.nb_lig), //initialisation du nombre de lignes
  nb_col(A.nb_col),  //initialisation du nombre de colonnes
  data(nullptr)      //initialisation de data à zéro
 {
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)   //allocation de l'espace où l'on va copier
      data[i]=new double [nb_col];
      } 
   catch(std::bad_alloc const& ba)
     {         
    if(data)
       {
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
       }
    delete[] data;
    throw;
     }
   for (std::size_t i=0; i<nb_lig; i++)    //on copie la matrice A élément par élément
    for (std::size_t j=0; j<nb_col; j++)
     data[i][j]= A.data[i][j];
 }




//Définition du destructeur
matrix::~matrix()
{ 
   for (size_t i =0; i< nb_lig ;i++)
    delete[] data[i];
    data = nullptr;
    nb_lig = 0;
    nb_col=0;

}


   



//Définition de l'opérateur d'accès aux éléments ():
double& matrix::operator()(std::size_t i,std::size_t j)
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}


double matrix::operator()(std::size_t i,std::size_t j) const
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}


//Définition de l'opérateur d'assignation

matrix& matrix::operator = (matrix const & A)
{
    
    matrix copy(A);//on crée une copie de A 
    swap(copy);///* on interverti les données de copy et de this */
    return  * this;
}

std::ostream& operator<<(std::ostream& out, const matrix& m)
{
  // write obj to stream
  return out;
}








//Définition de l'opérateur *
matrix matrix :: operator*(const matrix & m2)
{
    //vérifier que les deux matrices peuvent être multipliées
     
   if(nb_col != m2.nb_lig) 
{
std::cout<< "error dimension"<<std::endl;	
throw;
}
   matrix m(nb_lig,m2.nb_col);
    

     //Aik = sum_j(Bij * Cjk)
    for(std::size_t i=0;i<nb_lig;i++)
      {
       for(std::size_t k=0;k<m2.nb_col;++k)
         {
            for(std::size_t j=0;j<nb_col;j++)
             m( i,k) += data[ i][ j]* m2( j, k);
           }
      }
   return m;
}

.cpp

#include <iostream>
#include "matrice.h"
#include <cmath>
#include <fstream>
using namespace std;


int main()
 {

 matrix M(2,2);
 matrix V(2,1) ;
M(0,0)=1;
M(0,1)=0;
M(1,0)=1;
M(1,1)=2;



V(0,0)=4;
V(1,0)=0;


 
matrix prod(2,1);
prod= M*V;

for (size_t i=0; i<2; i++)
{
for (size_t j=0; j<1; j++)
std:: cout << prod(i,j)  << '\n';
}




 }

[imoca]

le resultat est bon pour moi

main.cpp

#include <iostream>
#include "matrice.h"
#include <cmath>
#include <fstream>
using namespace std;


int main()
 {
matrix M= matrix(2,2);
matrix V= matrix(2,1) ;
M.setVal(0,1,0.00);
M.setVal(1,0,1);
M.setVal(1,1,2);
M.setVal(0,0,0);
V.setVal(0,0,4);
V.setVal(1,0,0);
cout<<"M ";
M.aff();
cout<<"V ";
V.aff();
matrix prod(2,1);
prod= M*V;
cout<<"M*V ";
prod.aff();



    return 0;
 }

matrice.cpp

#include <iostream>
#include <cmath>
#include <iomanip>  // setprecision()
#include <cassert>  // assert()
using namespace std;

class matrix
{
private:


public:
    std::size_t nb_lig;
    std::size_t nb_col;
    double ** data;
     //Déclaration du constructeur par défaut
     matrix();

    //Déclaration du constructeur avec arguments
    matrix(std::size_t nb_lig,std::size_t nb_col);

  //Déclaration du constructeur de copie
   matrix(const matrix &);

   //Déclaration du destructeur
     ~matrix();

    //Déclaration de l'opérateur () d'accès aux éléments
    double&  operator()(std::size_t i , std::size_t j );//Déclaration de l'opérateur()
    double operator()(std::size_t i, std::size_t j) const;//Déclaration de l'opérateur()
    void aff();
    //Déclaration de l'opérateur d'assignement
    matrix& operator=(const matrix &A);
    void setVal(std::size_t i,std:: size_t j, double val);
    double getVal(std::size_t i,std:: size_t j);
   void swap(matrix & other){
        std::swap(nb_lig, other.nb_lig);
        std::swap(nb_col, other.nb_col);
        std::swap(data, other.data);
    }


    //Déclaration de l'opérateur *
     matrix operator*( const matrix & m2);


};






//Définition du constructeur par défaut
matrix::matrix():nb_lig(1), nb_col(1)
{
    data = NULL;
}

//Définition du constructeur avec arguments
 matrix::matrix(std::size_t nb_lig=1,std::size_t nb_col=1):
  nb_lig(nb_lig),
  nb_col(nb_col),
  data(NULL)
{
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)
      data[i]=new double [nb_col];
  } catch(std::bad_alloc const& ba){
    if(data){
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
    }
    delete[] data;
    throw;
  }
for (size_t i=0; i<nb_lig; i++){
    for (size_t j=0; j<nb_col; j++){
            data[i][j]=0.00;
    }
}
}


//Définition du constructeur de copie
 matrix::matrix(const matrix &A):
  nb_lig(A.nb_lig), //initialisation du nombre de lignes
  nb_col(A.nb_col),  //initialisation du nombre de colonnes
  data(NULL)      //initialisation de data à zéro
 {
  try{
    data=new double*[nb_lig];
    for (std::size_t i=0; i<nb_lig; i++)   //allocation de l'espace où l'on va copier
      data[i]=new double [nb_col];
      }
   catch(std::bad_alloc const& ba)
     {
    if(data)
       {
      for (std::size_t i=0; i<nb_lig; i++)
        delete[] data[i];
       }
    delete[] data;
    throw;
     }
   for (std::size_t i=0; i<nb_lig; i++)    //on copie la matrice A élément par élément
    for (std::size_t j=0; j<nb_col; j++)
     data[i][j]= A.data[i][j];
 }




//Définition du destructeur
matrix::~matrix()
{
   for (size_t i =0; i< nb_lig ;i++)
    delete[] data[i];
    data = NULL;
    nb_lig = 0;
    nb_col=0;

}






//Définition de l'opérateur d'accès aux éléments ():
double& matrix::operator()(std::size_t i,std::size_t j)
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}


double matrix::operator()(std::size_t i,std::size_t j) const
{
    assert(i >= 0 && i <= nb_lig);
    assert(j >= 0 && j <= nb_col);
    return data[i][j];
}

void matrix::setVal(std:: size_t i,std:: size_t j, double val){
    data[i][j]=val;
}

double matrix::getVal(std::size_t i,std:: size_t j){
    return this->data[i][j];
}
void matrix::aff(){
    cout<<"Afficher"<<endl;
    for (size_t i=0; i<nb_lig; i++){
        for (size_t j=0; j<nb_col; j++){
            cout<<data[i][j]<<" ";
        }
        cout<<endl;
    }
}
//Définition de l'opérateur d'assignation
matrix& matrix::operator = (matrix const & A)
{

    matrix copy(A);//on crée une copie de A
    swap(copy);///* on interverti les données de copy et de this */
    return  * this;
}
std::ostream& operator<<(std::ostream& out, const matrix& m)
{
  // write obj to stream
  return out;
}
//Définition de l'opérateur *
matrix matrix :: operator*(const matrix & m2)
{
    //vérifier que les deux matrices peuvent être multipliées

   if(nb_col != m2.nb_lig)
{
std::cout<< "error dimension"<<std::endl;
throw;
}
   matrix m(nb_lig,m2.nb_col);


     //Aik = sum_j(Bij * Cjk)
    for(std::size_t i=0;i<nb_lig;i++)
      {
       for(std::size_t k=0;k<m2.nb_col;++k)
         {
            for(std::size_t j=0;j<nb_col;j++)
             m( i,k) += data[ i][ j]* m2( j, k);
           }
      }
   return m;
}

matrice.h

#ifndef MATRIX_H
#define MATRIX_H


class matrix
{
    public:
        std::size_t nb_lig;
        std::size_t nb_col;
        double ** data;

        matrix();
        virtual ~matrix();
        matrix(std::size_t nb_lig=1,std::size_t nb_col=1);
        double& operator()(std::size_t i,std::size_t j);
        double operator()(std::size_t i,std::size_t j) const;
        matrix& operator = (matrix const & A);
        matrix operator*(const matrix & m2);
        void setVal(std::size_t i, std:: size_t j, double val);
        double getVal(std:: size_t i,std:: size_t j);
        void aff();
};

#endif // MATRIX_H