vecteurs en c++

[invite389df8bf]

Donc le code est:
fichier.h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int n);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double composante(int i); 
  double sym(int i, double val);
  void affiche();//déclaration de la fonction affiche
};

et le .cpp est

#include <iostream>
#include "exemple.h"
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}
vecteur::vecteur(int n)
{
  this->n = n;
  v = new double[n];
}

vecteur::~vecteur()
{}

double vecteur::composante(int i)
{
  return v[i];
}

double vecteur::sym(int i, double val)
{
  if(i>=n)
    cout<<"erreur";
  else
    val=v[i];
}

main()
{
  int i;
  vecteur v;
  std::cout<<"v=";cout<<"\n";
     
}

Maintenant, il faut rentrer les conposantes du vecteurs. Pour ca, il faut lui indiquer ce qu'est une composante: donc pour ça on a la fonction composante, et puis on donne la valeur et pour ça on utilise la fonction sym.

le problème est quedans ma tête, je n'arrive pas à faire le lien entre le constructeur par défaut, les fonctions composante et sym.
Dès qu'on écrit: vecteur v; le constructeur se met en marche, et ça ce n'est pas bien. En fait, comment organiser les choses? Je vous remercie par avance.
-----

[invite389df8bf]

En fait, j'ai encore modifié mon .cpp

#include <iostream>
#include "exemple.h"
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}
vecteur::vecteur(int n)
{
  this->n = n;
  v = new double[n];
}

vecteur::~vecteur()
{}

double vecteur::composante(int i)
{
  return v[i];
}

double vecteur::sym(int i, double val)
{
  if(i>=n)
    cout<<"erreur";
  else
    v[i]=val;
}



main()
{
  double val;
  int i;
  vecteur v;
  for (i=0;i<4;i++)
    {
    std::cout<<"la valeur de la première composante, est val=";cout<<"\n!";
    cin>>val;//on rentre une valeur val
    v.composante(i,val);//on devrait avoir val dans la case v [i]
}

ça ne marche pas, en fait parce que je n'arrive pas à lier la valeur val que je rentre, aux fonctions composante et sym. Comment faire un lien logique entre les 3? S'il vous plaît.
Je vous remercie par avance.

[invite389df8bf]

Je suis vraiment désolée pour les multi-postes, mais j'essayent toutes les iodées qui me semblent bonnes. Alors voilà, je me suis dit que puisque le problème vient du constructeur, il valait mieux utiliser l'idée de Jack, c'est à dire utiliser un constucteur avec deux argument, et qui initialise toute les composantes à 0. Ainsi;
le .h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double composante(int i);
  // double sym(int i, double val);
};

et le fichier.cpp

#include <iostream>
#include "exemple.h"
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}


//Définition de la fonction composante (au lieu de [])
double vecteur::composante(int i)
{
  return v[i];
}

//
//double vecteur::sym(int i, double val)
//{
//  if(i>=n)
//  cout<<"erreur";
// else
//  v[i]=val;
//return 0;
//}



main()
{
  std::cout<<"les valeurs des composantes de v sont:";cout<<"\n";
  vecteur v;

}

je me suis dit qu'avec ca, on n'aurait plus besoin de la fonction symétrique, mais le problème est que dès que je lui met int v; il me donne l'erreur

exemple.cpp: In function ‘int main()’:
exemple.cpp:48:11: error: call of overloaded ‘vecteur()’ is ambiguous
vecteur v;
^
exemple.cpp:48:11: note: candidates are:
exemple.cpp:13:1: note: vecteur::vecteur(int, double)
vecteur::vecteur(int nb, double val)
^
In file included from exemple.cpp:2:0:
exemple.h:9:2: note: vecteur::vecteur()
vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
^

il me dit que la notation vecteur(); est ambigue, si je lui met vecteur v(); ca marche, par contre là v n'est plus un vecteur.
Que faire? S'il vous plaît. Je vous remercie par avance.

[Paraboloide_Hyperbolique]

Bonsoir

Le compilateur vous renseigne: les deux fonctions:

vecteur():v(NULL),n(0){};
vecteur(int nb=0, double val=0) {... }

sont ambiguës.

En effet, lorsque j'écris "vecteur v;" Quel constructeur faut-il appeler ? Le constructeur par défaut ou le constructeur vector(int nb, double val) avec les valeurs par defaut nb = 0 et val = 0 ?
Comme il est impossible de le savoir, le compilateur renvoie une erreur...

[Jack]

En effet. C'est pourquoi j'avais montré en fin de mon message #42 que le constructeur avec ses 2 valeurs par défaut faisait office de constructeur par défaut.

[invite389df8bf]

D'accord, alors il vaut mieux initialiser avec le constructeur avec argument, ainsi nous n'aurons plus besoin de la fonction symétrique. Voici le .cpp

#include <iostream>
#include "exemple.h"
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}


//Définition de la fonction composante (au lieu de [])
double vecteur::composante(int i)
{
  return v[i];
}

//Définition de la fonction sym
double vecteur::sym(int i, double val)
{
  if(i>=n)
  cout<<"erreur";
 else
  v[i]=val;
return 0;
}



main()
{
  double val;
    vecteur v(int nb,double val);
  for(int i=0;i<4;i++)
    {
    std::cin>>val;
    v.composante(i);
    }

}

là il m'affiche l'erreur:
exemple.cpp: In function ‘int main()’:
exemple.cpp:52:7: error: request for member ‘composante’ in ‘v’, which is of non-class type ‘vecteur(int, double)’
v.composante(i);
^
et même en écrivant v(i,val).composante(i); , ca ne marche pas, ca renvoie une erreur. Pourtant, la fonction composante est bien définie, et pour l'appliquer à v, on écrit bien
élément de le classe.fonction(arguments).
Comment faire pour faire rentrer les composantes d'un vecteur de cette classe et les afficher proprement? S'il vous plaît.
Je vous remercie par avanve.

[Jack]

    vecteur v(int nb,double val);

Cette ligne n'a aucun sens????
Désolé, mais ton main c'est vraiment n'importe quoi. A quoi sert val? v.composante(i) ?????

je déconseille le cout dans la méthode sym pour la gestion des erreurs car ta classe ne pourra fonctionner que dans un terminal en mode texte. De plus à quoi te sert de retourner une valeur qui vaut toujours 0?

Tu devrais regarder à quoi ressemble une vraie classe vecteur, même si tu n'en implémentes qu'une partie:
http://www.cplusplus.com/reference/vector/vector/

Tu y verrais par exemple que l''accès à un élément du vecteur en lecture peut se faire à l'aide de l'opérateur [] ou la méthode at qui permet de gérer les débordement d'indice à l'aide du mécanisme d'exception (je te déconseille de t'y lancer pour le moment). On s'aperçoit donc que le contrôle des bornes avec l'opérateur [] n'est pas prévu: au programmeur de prendre ses précautions.

Pourquoi ne pas remplacer donc tes fonctions composantes et sym qui franchement ne sont pas très parlantes sur leur rôle par la surcharge de l'opérateur []? Ce n'est pas la mer à boire:
dans le fichier .h

double& operator[](int rang);

dans le .cpp:

double& vecteur::operator[](int rang)
{
  return v[rang]; 
}

et pour tester dans ton main.cpp:

//blablabla
vecteur v1(8);
v1[2] = 3;
cout << v1[1] << endl; // affiche 0;
cout << v1[2] << endl; // miracle, ça affiche 3
//etc.

C'est quand même plus facile à lire, non?

[invite389df8bf]

#### supprimé : phrase devenue inutile.

Alors le .h est

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);
  vecteur  operator+(vecteur  const & v);
  vecteur& operator=(vecteur const&);
  vecteur operator * (double d, const vecteur &v);
};

là il dit que l'opérateur * est mal déclaré: In file included from exemple.cpp:2:0:
exemple.h:16:49: error: ‘vecteur vecteur:perator*(double, const vecteur&)’ must take either zero or one argument
vecteur operator * (double d, const vecteur &v)



et j'ai aussi un problème, celui de retenir les définitions de ces opérateurs. Pouvez vous s'il vous plaît me donner une manière logique de les retenir? Je vous remercie par avance.

[invite389df8bf]

Bonjour,
pour l'opérateur d'affectation.
la déclaration se fait par:
vecteur& operator=(vecteur const& v);
pour l'implémentation, j'ai essayé pleins de trucs qui me renvoient toujours une erreur. Voici ce que j'ai essayé

vecteur: vecteur& operator=(vecteut const& v)
{
int n;
for(i=0;i<=n;i++)
{
v[i]=v.v[i];
}

et il m'envoir l'erreur:
exemple.cpp:37:37: error: ‘vecteur operator=(const vecteur&)’ must be a nonstatic member function
vecteur operator = (const vecteur &v)

comment l'aranger? S'il vous plaît.

[Jack]

Tu fais trop d'erreurs de syntaxe!
Rien que dans la 1ère ligne, j'en vois 3

[invite389df8bf]

Désolée, c'est mon clavier.
Bon, alors j'ai avancé un peu et voici mon fichier.h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
};

et mon fichier.cpp

#include <iostream>
#include "exemple.h"
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}

//Définition du destructeur
vecteur::~vecteur()
{}

//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}

//Définition de =

vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<=n;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}


//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(n);
for (int i=0;i<=n;i++)
d.v[i]=v[i]+a.v[i];
return d;
}

//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<=n;i++)
v[i]=d*v[i];
return *this;
}

//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<=n;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}

main()
{
  vecteur v1(8), v2(8);//vecteur à 8 composantes
double d=1.5;
  v1.affiche(); 
  v1[2]=3;
v2[1]=2;
vecteur somme(8);
somme=v1+v2;
somme.affiche();
vecteur msv(8);
msv=v2*d;
msv.affiche();
  //cout<<v1<<endl;//ca n'existe pas, donc il va afficher 0 qui est le constructeur par défaut
  //cout<<v1[2]<<endl;//

}

Mais je veux comprendre la logique de cette définition pour pouvoir les retenir facilement, et de façon logique. Quand et où on met les const, &, et return *this? S'il vous plaît. Je souhaite vraiment comprendre ces trois points. Je vous remercie par avance.

[invite389df8bf]

J'ai une deuxième question s'il vous plaît.
Je souhaite créer une fonction qui crée un vecteur C' et un vecteur C'' à partir d'un vecteur C, telles que: C'[0]=C[1], C'[1]=C[2],...,C'[n-1]=C[n], et C'[n]=C[0]
et pour C'': C''[0]=C[0], C''[1]=C[0],....,C''[n]=C[n-1]
Pour ca j'ai défini deux fonctions: une décalé à gauche et une autre décalée à droite.
Coici le fichier.h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
  vecteur decd(const vecteur&);
  vecteur decg(const vecteur&);
};

mon fichier.cpp

#include <iostream>
#include "exemple.h"
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}

//Définition du destructeur
vecteur::~vecteur()
{}

//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}

//Définition de =

vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<=n;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}


//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(n);
for (int i=0;i<=n;i++)
d.v[i]=v[i]+a.v[i];
return d;
}

//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<=n;i++)
v[i]=d*v[i];
return *this;
}

//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<=n;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}


//Définition de la fonction décalée à droite
vecteur vecteur :: decd(const vecteur &C)
{
vecteur C;
v[n-1]=C.v[0];
for (int i=0;i<n-1;i++)
v[i]=C.v[i+1];
return *this;
}

//Définition de la fonction décalée à gauche
vecteur vecteur:: decg(const vecteur &C)
{
v[0]=C.v[n-1];
for(inti=1;i<n;i++)
v[i]=C.v[i-1];
return *this;
}


main()
{
  vecteur v1(8), v2(8);//vecteur à 8 composantes
double d=1.5;
  v1.affiche(); 
  v1[2]=3;
v2[1]=2;
vecteur somme(8);
somme=v1+v2;
somme.affiche();
vecteur msv(8);
msv=v2*d;
msv.affiche();
  //cout<<v1<<endl;//ca n'existe pas, donc il va afficher 0 qui est le constructeur par défaut
  //cout<<v1[2]<<endl;//

}

j'ai tout essayé pour arranger les déclarations suivante:

//Définition de la fonction décalée à droite
vecteur vecteur :: decd(const vecteur &C)
{
vecteur C;
v[n-1]=C.v[0];
for (int i=0;i<n-1;i++)
v[i]=C.v[i+1];
return *this;
}

//Définition de la fonction décalée à gauche
vecteur vecteur:: decg(const vecteur &C)
{
v[0]=C.v[n-1];
for(int i=1;i<n;i++)
v[i]=C.v[i-1];
return *this;
}

mais j'ai toujours l'erreur suivante:

xemple.cpp:80:9: error: declaration of ‘vecteur C’ shadows a parameter
vecteur C;
^
exemple.cpp:80:9: error: call of overloaded ‘vecteur()’ is ambiguous
exemple.cpp:80:9: note: candidates are:
exemple.cpp:13:1: note: vecteur::vecteur(int, double)
vecteur::vecteur(int nb, double val)
^
In file included from exemple.cpp:2:0:
exemple.h:9:2: note: vecteur::vecteur()
vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut

Comment le corriger? S'il vous plaît. Je vous remercie par avance.

[Jack]

Quand et où on met les const

On met const pour être sur de ne jamais modifier la valeur correspondante au cours de la fonction. De plus, l'utilisateur de cette fonction est rassuré car il sait que son paramètre gardera son intégrité et retrouvera sa valeur après l'appel de la fonction.

&

Il est préférable de passer une référence sur un objet dans la liste ds paramètres, afin d'éviter la perte de temps due à sa copie. Récupérer une référence en valeur de retour permet également de récupérer une valeur pouvant être utilisée en membre de gauche d'une affectationar exemple, pour l'opérateur [], si on ne retournait pas une référence, il serait impossible d'écrire:

vecteur v1(5);
v1[3]= 2.5;

et return *this

Dans la redéfinition des opérateurs en temps que fonction membre, un des opérandes est obligatoirement l'objet lui-même. Si l'objet doit être modifié au cours du calcul et retourner sa nouvelle valeur, on retourne cette valeur à l'aide de *this.

Je te conseille de (re)lire (attentivement) la FAQ sur la redéfinition des opérateurs dont je t'ai donné le lien.

[Jack]

//Définition de la fonction décalée à droite
vecteur vecteur :: decd(const vecteur &C)
{
   vecteur C;

Tu peux expliquer la dernière ligne du dessus?

//Définition de *

vecteur vecteur:: operator*(double  d)
{
    for(int i=0;i<=n;i++)

je t'ai déjà expliqué qu'il ne fallait pas taper en dehors de l'espace de stockage du vecteur, donc du tableau de doubles. Ton indice de boucle i va donc trop loin, il faut que ta condition soit i < n

[invite389df8bf]

pour la ligne dessus, c'est faux, il faut enlever vecteur C;C'est ca?
Je l'ai arangé ainsi et ça marche. Qu'en dite vous?
fichier.h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
  vecteur decd(const vecteur&);
  vecteur decg(const vecteur&);
};

et pour le fichier.cpp

#include <iostream>
#include "exemple.h"
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}

//Définition du destructeur
vecteur::~vecteur()
{}

//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}

//Définition de =

vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<n;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}


//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(n);
for (int i=0;i<n;i++)
d.v[i]=v[i]+a.v[i];
return d;
}

//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<n;i++)
v[i]=d*v[i];
return *this;
}

//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<=n;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}


//Définition de la fonction décalée à droite
vecteur vecteur :: decd(const vecteur &C)
{
v[n-1]=C.v[0];
for (int i=0;i<n-1;i++)
v[i]=C.v[i+1];
return *this;
}

//Définition de la fonction décalée à gauche
vecteur vecteur:: decg(const vecteur &C)
{
v[0]=C.v[n-1];
for(int i=1;i<n;i++)
v[i]=C.v[i-1];
return *this;
}


main()
{
  vecteur v1(8), v2(8);//vecteur à 8 composantes
double d=1.5;
  v1.affiche(); 
  v1[2]=3;
v2[1]=2;
vecteur somme(8);
somme=v1+v2;
somme.affiche();
vecteur msv(8);
msv=v2*d;
msv.affiche();
  //cout<<v1<<endl;//ca n'existe pas, donc il va afficher 0 qui est le constructeur par défaut
  //cout<<v1[2]<<endl;//

}

Qu'est ce que vous en dites? On peut l'améliorer?
Aussi, quand on écrit vecteur::vecteur nom(const vecteur &c);
et on met c.v[i] je comprend que ca veut dire que c est la composante numéro i du vecteur c, mais pourquoi on n'écrit pas directement c[i]?
Je vous remercie beaucoup.

[Jack]

et on met c.v[i] je comprend que ca veut dire que c est la composante numéro i du vecteur c, mais pourquoi on n'écrit pas directement c[i]?

Ca n'a aucun rapport:
c[i] est le ième élément de ton vecteur, [] étant un opérateur redéfini pour ta classe vecteur
v[i] est le ième élément de ton tableau v, [] étant l'opérateur standard de C/C++ pour accéder à un élément du tableau
c.v[i] est le ième élément du tableau v, v étant un membre du vecteur c

[invite389df8bf]

Je ne comprend pas la dérnière s'il vous plaît. v est un vecteur étant un élément de la classe vecteur, comment peut-il être membre d'un autre vecteur c?

[Jack]

tu n'as pas bien lu. Je n'ai jamais dit que v était un vecteur.

Souviens-toi, c'est tout de même toi qui as codé ta classe:

class Vecteur{
private:
int N;
double *v;

[invite389df8bf]

D'accord, j'ai compris maintenant.
Un dérnier point s'il vous plaît. J'ai créer les foncions decg (décalée à gauche) et decd (décalée à droite), pour calculer ceci:
$$C^{n+1}_j = \alpha C^n_j+ \beta (C^{n}_{j-1} + C^n_{j+1}) + \gamma C^n_{j-1}, 1 \leq j \leq N, 0 \leq n \leq M-1,$$
$$C^0_j=0, C_0^n=1, C^n_{N+1}=0$$
Donc pour faire ce calcil, je pense qu'il est bien de faire une boucle sur n en utilisant des éléments de la classe, qui sont des vecteurs, donc pas besoin de faire une boucle sur j. Vous ête d'accord avec cette idée?
Alors pour le code, j'ai pensé à ça:

for (n=0;M-1;n++)
{
vecteur C;
C[n+1]=alpha*C[n] + beta*(C.decg+C.decd) + gamma*C.decg;
}
C.affiche()

Bon, il m'affiche beaucoup d'erreurs,mais je sais que je deverai mettre un argument pour decd et decg quand j'écris C.decg, mais quel argument utiliser? Je vous remercie par avance.

[Jack]

$$C^{n+1}_j = \alpha C^n_j+ \beta (C^{n}_{j-1} + C^n_{j+1}) + \gamma C^n_{j-1}, 1 \leq j \leq N, 0 \leq n \leq M-1,$$
$$C^0_j=0, C_0^n=1, C^n_{N+1}=0$$

il ne manque pas une balise TEX ou un truc comme çà?

Je souhaite créer une fonction qui crée un vecteur C' et un vecteur C'' à partir d'un vecteur C, telles que: C'[0]=C[1], C'[1]=C[2],...,C'[n-1]=C[n], et C'[n]=C[0]
et pour C'': C''[0]=C[0], C''[1]=C[0],....,C''[n]=C[n-1]

En passant, tu es sur de tes décalages? Ils n'ont pas l'air symétriques. Le décalage à droite effectue plutôt une rotation ou permutation circulaire alors que le décalage à gauche recopie le 1er élément au lieu de le remplacer par le dernier

[invite389df8bf]

Pardon pour les balises, voici l'expression:


pour les décalage, à partir de C, on crée deux vecteurs: C' et C'' t.q:
C'[j]=C[j+1], pour tout et C''[j]=C[j-1] pour tout , et on pose C'[n]=C[0] et C""[0]=C[0].
il y'a un problème avec les emplacements de v et C.v?
Je ne comprend pas le problème dans mon écriture, alors comment le corriger? S'il vous plaît.

[invite389df8bf]

***Suite****
est-ce que l'écriture suivante est la bonne?
//Définition de la fonction décalée à droite

vecteur vecteur :: decd(const vecteur &C)
{
v[n-1]=C.v[0];
for (int i=0;i<n-1;i++)
C.v[i]=C[i+1];
return *this;
}

car on a un vecteur C, et on met la (i+1) ème composante de ce vecteur dans le i-ème élément du tableau afin de créer le vecteur C'.
C'est comme ca? Sinon comment le corriger s'il vous plaît?
2- et pour le calcul de quels paramètres on donne aux fonctions décalée quand on les appelle? Je vous remercie beaucoup.

[invite389df8bf]

Dans le code précédent, je voulais écrire

vecteur vecteur :: decd(const vecteur &C)
{
v[n]=C.v[0];
for (int i=0;i<n-1;i++)
C.v[i]=C[i+1];
return *this;
}

en fait ici, on est entrain de créer le vecteur C', donc pas la peine de faire intervenir une 3ème case. Comment le corriger? S'il vous plaît.

[invite389df8bf]

Bonjour, désolée encore une fois pour le multi-poste. Voici comment je défini lesfonction décalée à droite et décalée à gauche:

//Définition de la fonction décalée à droite
vecteur vecteur::decd(const vecteur &C)
{
for(int j=0;n-1;j++)
v[j]=C.v[j+1];
return *this;
}

//Définition de la fonction décalée à gauche
vecteur vecteur::decg(const vecteur &C)
{
for (int j=n;1;j--)
v[j-1]=C.v[j];
return *this;
}

Qu'est ce que vous en dite? Et comment les arranger? S'il vous plaît.

[invite389df8bf]

Voici mes dérnières implémentations pour la fonction décalée à droite:

//Définition de la fonction décalée à droite
vecteur decd(const vecteur &C)
{
int n;
vecteur w(n);
w[0]=C[n-1];
for (int i=0;i<n-1;i++)
w[i]=C[i+1];
return w;}

mais ca ne marche pas. Comment aranger s'il vous plaît?

et s'il vous plaît, comment appeler ces fonctions decd et decg?

[Jack]

Il me semble que tu n'as pas compris la "philosopie" de la POO. La méthode decd doit être appliquée à ton objet, donc doit être appelée ainsi:

vecteur v(5);  // par exemple
v.decd();  // décale le vecteur à droite

La méthode est appliquée à l'objet lui même, donc pas besoin d'en passer un en paramètre, à moins que je n'aie pas compris ce que tu veux faire de ce décalage.
Le prototype de cette méthode, déclaré dans la partie publique de la classe, doit donc être:
void decd();

[invite389df8bf]

Non, ca ne compile pas si je fais ainsi.
Voici mon fichier.h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
  void decd();
  void ();
};

et le .cpp

#include <iostream>
#include "exemple.h"
#include <cmath>
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}

//Définition du destructeur
vecteur::~vecteur()
{}

//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}

//Définition de =

vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<n;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}


//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(n);
for (int i=0;i<n;i++)
d.v[i]=v[i]+a.v[i];
return d;
}

//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<n;i++)
v[i]=d*v[i];
return *this;
}

//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<n;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}


//Définition de la fonction décalée à droite
void vecteur :: decd()
{
v[0]=C.v[n-1];
for (int i=0;i<n-1;i++)
v[i+1]=C.v[i];
return *this;}


main()
{

vecteur v(3);
v[0]=10;
v[1]=2;
v[2]=4;
v.decd();


}

Où est le problème? S'il vous plaît.

[Jack]

Non, ca ne compile pas si je fais ainsi.

C'est normal vu la définition de ta méthode decd.
Je te laisse réfléchir car pour le coup le problème est assez évident.

PS en fait, il y a 2 problème évidents. Lis attentivement tes messages d'erreur

[invite389df8bf]

En fait, pourquoi void? Puisque la fonction décalée va nous renvoyer un vecteur (on en aura besoin pour faire le calcul final). J'ai fini le programme et il marche.
fichier.h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
  vecteur decd(const vecteur&);
  vecteur decg(const vecteur&);
  fstream flux("fichier.txt", ios::in | ios::out | [ios::ate]);.   
};

fichier.cpp

#include <iostream>
#include "exemple.h"
#include <cmath>
#include <fstream>
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}

//Définition du destructeur
vecteur::~vecteur()
{}

//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}

//Définition de =

vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<n;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}


//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(n);
for (int i=0;i<n;i++)
d.v[i]=v[i]+a.v[i];
return d;
}

//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<n;i++)
v[i]=d*v[i];
return *this;
}

//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<n;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}


//Définition de la fonction décalée à droite
vecteur vecteur :: decd(const vecteur &C)
{
v[0]=C.v[n-1];
for (int i=0;i<n-1;i++)
v[i+1]=C.v[i];
return *this;}

//Définition de la fonction décalée à gauche
vecteur vecteur:: decg(const vecteur &C)
{
v[n-1]=C.v[0];
for(int i=1;i<n;i++)
v[i-1]=C.v[i];
return *this;
}


main()
{

/*vecteur v(3);
v[0]=10;
v[1]=2;
v[2]=4;
vecteur vd(3);
v.affiche();
vd.decd(v);
vd.affiche();*/


/*vecteur w(3);
w[0]=10;
w[1]=2;
w[2]=4;
vecteur vg(3);
w.affiche();
vg.decg(w);
vg.affiche();*/



//les data
double L=1000.;
double T=3860.;
double phi=0.3;
double D=0.1;
double v=0.05;
int n=99;
int M=99;

double delta=T/(M+1);
double h=L/(n+1);
double a=(D/phi)*(delta/pow(h,2));
double b=(v/phi)*(delta/h);


//calcul de C:
vecteur C(n);
vecteur can(n);
C[0]=1;
C[n+1]=0;
vecteur Cd(n);
vecteur Cg(n);

for(int j=0;j<M;j++)
{
Cd=Cd.decd(can);
Cg=Cg.decg(can);
C=can*(1.-2.*a-b)+(Cg+Cd)*a+Cg*b;
C[0]=1;
C[n+1]=0;
can=C;
}
C.affiche();

ofstream fichier("resultat.txt", ios::out | ios::trunc);  // ouverture en écriture avec effacement du fichier ouvert

  

  //vecteur v1(8), v2(8);//vecteur à 8 composantes
//double d=1.5;
  //v1.affiche(); 
  //v1[2]=3;
//v2[1]=2;
//vecteur somme(8);
//somme=v1+v2;
//somme.affiche();
//vecteur msv(8);
//msv=v2*d;
//msv.affiche();
  //cout<<v1<<endl;//ca n'existe pas, donc il va afficher 0 qui est le constructeur par défaut
  //cout<<v1[2]<<endl;//

}

il marche bien, sauf quand je rajoute la commande pour stocker le résultat que l'on lit sur le terminal, dans un fichier.txt (j'ai recopier cette commande d'un cours du net). Quelle est cette commande? S'il vous plaît. Je vous remercie par avance.

[invite389df8bf]

Non, alors voici mon problème. Pour faire le calcul suivant:

où et
avec les données suivante: .
Voici le fichier.h

#include<iostream>
using namespace std;
class vecteur
{
 private:
  int n;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),n(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
  vecteur decd(const vecteur&);
  vecteur decg(const vecteur&);   
};

et voici le fichier .cpp

#include <iostream>
#include "exemple.h"
#include <cmath>
#include <fstream>
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): n(ref.n)
{
  v = new double[n];
  for(unsigned int i=0; i<n;i++)
    v[i]=ref.v[i];
}

//Définition du constructeur avec argument
vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}

//Définition du destructeur
vecteur::~vecteur()
{}

//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}

//Définition de =

vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<n;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}


//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(n);
for (int i=0;i<n;i++)
d.v[i]=v[i]+a.v[i];
return d;
}

//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<n;i++)
v[i]=d*v[i];
return *this;
}

//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<n;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}


//Définition de la fonction décalée à droite
vecteur vecteur :: decd(const vecteur &C)
{
v[0]=C.v[n-1];
for (int i=0;i<n-1;i++)
v[i+1]=C.v[i];
return *this;}

//Définition de la fonction décalée à gauche
vecteur vecteur:: decg(const vecteur &C)
{
v[n-1]=C.v[0];
for(int i=1;i<n;i++)
v[i-1]=C.v[i];
return *this;
}


main()
{

/*vecteur v(3);
v[0]=10;
v[1]=2;
v[2]=4;
vecteur vd(3);
v.affiche();
vd.decd(v);
vd.affiche();*/


/*vecteur w(3);
w[0]=10;
w[1]=2;
w[2]=4;
vecteur vg(3);
w.affiche();
vg.decg(w);
vg.affiche();*/



//les data
double L=1000.;
double T=3860.;
double phi=0.3;
double D=0.1;
double v=0.05;
int n=99;
int M=99;

double delta=T/(M+1);
double h=L/(n+1);
double a=(D/phi)*(delta/pow(h,2));
double b=(v/phi)*(delta/h);



//calcul de C:
vecteur C(n+2);
vecteur can(n+2);
C[0]=1;
C[n+1]=0;
vecteur Cd(n+2);
vecteur Cg(n+2);

for(int j=0;j<M;j++)
{
Cd=Cd.decd(can);
Cg=Cg.decg(can);
C=can*(1.-(2.*a)-b)+(Cg+Cd)*a+Cg*b;
C[0]=1;
C[n+1]=0;
can=C;
}
C.affiche();

ofstream fichier("resultat.txt", ios::out | ios::trunc);  // ouverture en écriture avec effacement du fichier ouvert
for(int i=0;i<=n+1;i++)
fichier<< i*h<<" "<<C[i]<<endl;  

  //vecteur v1(8), v2(8);//vecteur à 8 composantes
//double d=1.5;
  //v1.affiche(); 
  //v1[2]=3;
//v2[1]=2;
//vecteur somme(8);
//somme=v1+v2;
//somme.affiche();
//vecteur msv(8);
//msv=v2*d;
//msv.affiche();
  //cout<<v1<<endl;//ca n'existe pas, donc il va afficher 0 qui est le constructeur par défaut
  //cout<<v1[2]<<endl;//

}

Le problème est qu'il fonctionne mais il ne me donne pas de bons résultats. Pouvez vous m'indiquer quel est le problème s'il vous plaît. Je vous remercie par avance.