vecteurs en c++

[Jack]

Fais un effort dans la présentation de ton code. Indente-le parce que c'est vraiment fatigant à lire.

En fait, pourquoi void? Puisque la fonction décalée va nous renvoyer un vecteur (on en aura besoin pour faire le calcul final)

C'est pour la manière dont tu as créé la fonction decd. Personnellement, je n'aurais pas fait comme çà, mais c'est toi qui vois.

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?

Voir la classe fstream. En passant, le flux que tu déclare dans ta classe devrait plutôt être privé en raison de l'intérêt de l'encapsulation des données non indispensables aux utilisateurs de la classe. J'opterais de plus pour l'utilisation d'une variable de type string pour le nom physique du fichier associé au flux.

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

Quelqu'un t'a déjà conseillé l'utilisation d'un débogueur. Je crois que c'est le moment de te lancer.
-----

[invite389df8bf]

C'est ok, camarche maintenant, j'avais mal défini les fonction décalée. En fait je voudrai m'entrainer sur ce programme, et après voir les autres écritures possibles.
Alors 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&);   
};

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[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 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);
cout<< "a="<< a<<endl;
cout<<"b="<<b<<endl;



//calcul de C:
vecteur C(n+2), c1(n+2),c2(n+2),c3(n+2);
vecteur can(n+2);
C[0]=1;
C[n+1]=0;
can[0]=1;
can[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);
c1=can*(1.-(2.*a)-b);
c2=(Cg+Cd)*a;
c3=Cg*b;
C=c1+c2+c3;
cout<<"c1"<<endl;
c1.affiche();
cout<<"c2"<<endl;
c2.affiche();
cout<<"c3"<<endl;
c3.affiche();

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;//

}

Ma question maintenant, est comment modifier ce programme en utilisant les templates? Je sais qu'une classe template est une classe où les attributs sont d'un type T qui peut prendre n'importe quel type. Et il faut déclarer ce type générique en utilisant

 template<typename T>.

et remplaçer tout les types que l'on a utiliser par T. Mais on a deux attributs qui sont de types différents, comment faire? Pus dans le main comment on remplace le type générique T par le type dont on a besoin? C'est cela que je souhaite comprendre s'il vous plaît. Je vous remercie par avance.

[Jack]

Mais on a deux attributs qui sont de types différents, comment faire?

Rien n'interdit d'avoir plusieurs paramètres de types différents:
template <class T, class U>
Mais je ne vois pas trop pourquoi tu aurais besoin de 2 types différents dans ta classe vecteur.

Pus dans le main comment on remplace le type générique T par le type dont on a besoin?

C'est le principe même de la classe template. Par exemple, la classe vector de la STL est une classe template. on peut donc faire des vecteurs d'int , de double, de n'importe quoi en fait:

vector <int> v1;
vector <double> v2;
vector <nimporteQuelTypeDefini> v3;

[invite389df8bf]

donc la syntaxe de la classe Template, c'est de rajouter avant la dééfinition de la classe

template<typename T>

et après, lors de la déclaration des éléments de la classe, on ne met plus vecteur V, mais vecteur<double>v pour dire que les composantes sont par exemple de type double.
Quant aux attributs, qui sont n et v, on les laisse tels quels: int n et double *v. Les seuls changements sont quand on déclare un élément de la classe on ajoute un <type> entre le nom de la classe et le nom de l'élément. C'est bien ca? Mais où est-ce qu'on met le type générique T lorsqu'on défini une classe template?
2- et est-ce qu'il y'a des changement aussi dans le header ou bien seulement dans le .cpp?
Je vous remercie par avance.

[Jack]

Quant aux attributs, qui sont n et v, on les laisse tels quels: int n et double *v

Donc tu voudrais faire un vecteur d'int par exemple et tu continuerais à stocker les données dans un tableau de double ????.

Mais où est-ce qu'on met le type générique T lorsqu'on défini une classe template?

Il me semble logique que ce soit T* v;

[invite389df8bf]

Bon, je revise encore les template et je reviens. Merci beaucoup.