Créer un classe de matrice

Bonjour à tous,
Je débute en c++ et je voudrais réaliser un classe de matrice.On m'a donné le .h et on m'a demandé de réaliser un .cc afin de définir tout d'abord une classe de vecteurs puis la classe de matrice proprement dite.

Voici le matrice.h:

class Vecteur {
private :
unsigned int n ; // Ta i l l e du v e c t e ur
double* p ;//création de p par allocation dynamique
public :

Vecteur ( int _n ) : n ( _n ) , p (new double [ _n ] )

{
for ( int i=0; i<n ; ++i )
p [ i ] = 0 ;//initialisation à zero
}

Vecteur ( const Vecteur&);
Vecteur& operator=(const Vecteur&);//assignation

double& operator ( ) ( int i ) {return p [ i ] ; }
double operator ( ) ( int i ) const {return p [ i ] ; }//donne l'élément de la i ème ligne

unsigned int size ( ) const {return n ; }
~Vecteur ( ) { delete [ ] p ; } // Un d e s t ruc t eur , rend l a mémoire
// dynamiquement a l l o u é par l e
// c ons t r u c t e u r quand l e Vecteur
// e s t d é t r u i t .
} ;
extern Vecteur operator+(const Vecteur&, const Vecteur&);//additionne deux vecteurs
extern Vecteur operator-(const Vecteur&, const Vecteur&);//soustrait deux vecteurs
extern Vecteur operator *(double , const Vecteur&);//multiplie deux vecteurs par une constante
inline Vecteur operator *( const Vecteur& x , double alpha )//?
{
return alpha*x ;
}

class Matrice {
private :
unsigned int nx ;// Nombre de lignes (1er paramètre)
unsigned int ny ;// Nombre de colonnes (2ème paramètre)
double* p ;
public :
Matrice (unsigned int _nx , unsigned int _ny ) ;//défini la taille de la matrice
Matrice ( const Matrice& a ) ;
Matrice& operator=(const Matrice&);//assignation
double& operator ( ) ( int i , int j ) {return p [ nx*i+j ] ; }
double operator ( ) ( int i , int j ) const {return p [ nx*i+j ] ; }//retour l'élément (i,j)
unsigned int nb_lines ( ) const {return nx ; }
unsigned int nb_columns ( ) const {return ny ; }
~Matrice ( ) ;
} ;
extern Matrice operator+(const Matrice&, const Matrice&);
extern Matrice operator-(const Matrice&, const Matrice&);
extern Matrice operator *(double , const Matrice&);
inline Matrice operator *( const Matrice& A , double alpha )
{
return alpha*A ;
}
extern Matrice operator *( const Matrice&, const Matrice&);
extern Vecteur operator *( const Matrice&, const Vecteur&);


J'ai plusieurs questions:

1) Que signifie cette ligne de code "Vecteur ( int _n ) : n ( _n ) , p (new double [ _n ] )"
Je ne comprend pas l'underscore avant le n
2)Je ne vois pas comment définir les opérateurs suivants:

Vecteur ( const Vecteur&);

je ne vois pas à quoi cela peu servir

Vecteur& operator=(const Vecteur&);//assignation

Je n'arrive pas à définir l'assignation pour un vecteur de taille n quelconque

Salut,

1) A "rien". Pour le compilo, c'est un peu comme si ce caractère faisait parti de l'alphabet au même titre que a,b,c... Celui qui a écrit ton source à mis ça simplement pour avoir un nom de paramètre différent du nom de l'attribut n.

2) Pour le premier opérateur, c'est le constructeur par copie. Faut simplement que tu initialises ton vecteur avec les données de la copie passée en paramètre.
Dans ce genre là quoi :

Vecteur::Vecteur ( const Vecteur& v)
{
  n = v.size();
  p = new double[n];
  for (int i = 0 ; i < n ; i++)
    p[i] = v(i);
}


Pour le =... Bin ça doit être un code très proche de celui du constructeur par copie, sauf que le tableau p peut déjà contenir des valeurs, donc attention à pas faire de fuite de mémoire.

---

3ème année en ecole d'ingé d'info cherche stage de 4 mois à partir du 01/04/08

L'ajout d'un underscore "_" devant chaque  variable recu en argument n'est d'intérêt que pour améliorer la visibilité du programme. Au meme titre que "m_" devant les variables membres d'une classe, ou l'ajout d'un "l" (ex "int lValue") pour les variables locales.

Salut,
1) il s'agit comme ont dit les autres avant moi d'un nom de variable comme tout autre nom.
   la ligne Vecteur(int _n):n(_n),p(new double[_n]){} est le constructeur par defaut avec les variables initialisees avec les valeurs entre parentheses ( c comme si tu mettais un operateur d'affectation = ).

2)
    Vecteur ( const Vecteur&); contructeur par copie (par reference)
    Vecteur& operator=(const Vecteur&);//surcharge de l'operateur d'affectation

   l'operateur d'affectation effectue les memes operations( en general) que le constructeur par copie et retourne une reference sur le resultat, contrairement au constructeur par copie. Une maniere de les ecrire pour montrer a quel point les 2 implementations se ressemblent:
Vecteur::Vecteur ( const Vecteur& v)
{
    if(this==&v)return;
    if(!p)p = new double[n];
    *this = v;
}
Vecteur& Vecteur::operator=(const Vecteur& v)
{
    for(int i=n;--i>=0;)p[i]=v.p[i];
}

J'espere avoir aide, salut

je suis heureux de faire partie d'une grande famille ...!

salut , petit oubli :
Vecteur& Vecteur::operator=(const Vecteur& v)
{
    for(int i=n;--i>=0;)p[i]=v.p[i];
    return (*this);
}

je suis heureux de faire partie d'une grande famille ...!

j'ai compris pour l'implémentation de l'opérateur d'assignation.Par contre pour l'addition et la multiplication par un réel j'ai plein de problèmes.
Voici mon code
Vecteur& Vecteur::operator *(double& alpha, const Vecteur& x)
{
    new Vecteur multr
    for(int i=n;--i>=0;)
    multr(i)=alpha*x(i);
    return (multr);

}
Vecteur::operator+(const Vecteur& u, const Vecteur& x)
{
    new Vecteur plus
    for(int i=n;--i>=0;)
    plus(i)=u(i)+x(i);

    return (plus);

}

mon compilateur me retourne que je n'ai aps défini les opérateur dans le .h
Je suis perdu.

Salut,

dans le .hpp (le header de la classe) ajoute :

const Vecteur operator*(const double& alpha)const; // multiplie un vecteur par un double
friend const Vecteur operator*(const double& alpha,const Vecteur& v);// multiplie un double par un vecteur

const Vecteur operator+(const Vecteur& v)const; // additionne un vecteur avec un vecteur

 

 

dans le .cpp (dans l'implementation) :
const Vecteur Vecteur::operator *(const double& alpha)const
{
    Vecteur m = *this;
    for(int i=n;--i>=0;)
    m(i)=alpha*(*this)(i);
    return m;
}
const Vecteur operator *(const double& alpha,const Vecteur& u)
{
    Vecteur m = u;
    for(int i=n;--i>=0;)
    m(i)=alpha*u(i);
    return m;
}

const Vecteur Vecteur::operator+(const Vecteur& u)const
{
    Vecteur m = *this;
    for(int i=n;--i>=0;)
    m(i)=u(i)+(*this)(i);
    return m;
}

J'espere avoir aide, salut
je suis heureux de faire partie d'une grande famille ...!

Je n'ai pas le droit de modifier le .h mais je crois que cela à déjà été implémenté dans le .h