vecteurs en c++

[invite389df8bf]

Vous m'aidez juste ces premiers temps s'il vous plaît, et une fois que j'aurai compris ce problème c'est bon, je vous promet d'être autonome.
Je lis et je réfléchis à vos remarques. Merci beaucoup.
-----

[invite389df8bf]

Alors voilà, j'ai corrigé les erreurs et j'ai repéré dux autres erreurs que j'ai corrigé.
Voici mon nouveau fichier.h

include<iostream>
using namespace std;
typedef double R;//définition du corps
class vecteur
{
 private:
  int n;//taille
  R *v;//pointer les composantes
 public:
 vecteur():v(nullptr),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
  void affiche();//déclaration de la fonction affiche
};

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)
{
  tab = 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 n):n
{
  table = new double[n];
}
main()
{

  std::cout "affichier q.c.q";
}

et il me donne les erreurs suivantes:

exemple.h:1:1: error: ‘include’ does not name a type
include<iostream>
^
exemple.h: In constructor ‘vecteur::vecteur()’:
exemple.h:10:14: error: ‘nullptr’ was not declared in this scope
vecteur():v(nullptr),n(0){};//Déclaration et définition du constructeur par défaut
^
exemple.cpp: In copy constructor ‘vecteur::vecteur(const vecteur&)’:
exemple.cpp:7:3: error: ‘tab’ was not declared in this scope
tab = new double[n];
^
exemple.cpp: In constructor ‘vecteur::vecteur(int)’:
exemple.cpp:13:1: warning: extended initializer lists only available with -std=c++11 or -std=gnu++11
{
^
exemple.cpp:14:3: error: ‘table’ was not declared in this scope
table = new double[n];
^
exemple.cpp:14:24: error: expected ‘}’ before ‘;’ token
table = new double[n];
^
exemple.cpp:14:24: error: cannot convert ‘<brace-enclosed initializer list>’ to ‘int’ in initialization
exemple.cpp:14:24: error: expected ‘{’ before ‘;’ token
exemple.cpp: At global scope:
exemple.cpp:15:1: error: expected declaration before ‘}’ token
}
^


Bon, pour la définition du constructeur de copie, c'est bête de mettre 0, mais alors on ne met rien, et quand je n'ai rien mis il a donné des erreurs. Comment corriger s'il vous plaît, guidez moi juste pour maitriser les notions qu'il faut à travers cet exemple. Je vous remercie par avance.

[invite389df8bf]

***suite***
je pense qu'il y'a une erreur à la définition du constructeur de copie. pourquoi utiliser tab et ref? ref suffit. Non?

[pm42]

Je pense surtout que si tu met include au lieu de #include au début de ton .h, ça marche moins bien...
Le compilateur te dit aussi que tu as un symbole nullptr jamais défini.

[invite389df8bf]

Super merci beaucoup! Je fais que des bêtise.
À présent, il ne me marque que ces deux erreurs:

exemple.h:10:14: error: ‘nullptr’ was not declared in this scope
vecteur():v(nullptr),n(0){};//Déclaration et définition du constructeur par défaut

donc la défénition du constructeur par argument est bonne. Il reste le nullptr, mais je l'avais jamais utilisé avant. Comment le définir s'il vous plaît?

[Paraboloide_Hyperbolique]

Bonsoir,

Le mot-clef "nullptr" fait partie du standard C++11. Si l'on souhaite utiliser ce mot-clef, il faut alors spécifier au compilateur (pour la plupart des compilateurs actuels en tout cas) que l'on souhaite utiliser la norme C++11.
La manière de le faire dépend du compilateur considéré.

Sinon, vous pouvez remplacer "nullptr" par la valeur "NULL" (toutes les lettres sont en majuscules).

Au passage, je salue Jack pour sa patience et son endurance face aux questions de hinanehinane.

[invite389df8bf]

Merci beaucoup pour cette information. J'ai donc mis NULL.
Ainsi, il me renvoie maintenant une erreur sur la définition du constructeur de copie

exemple.cpp:7:3: error: ‘tab’ was not declared in this scope
tab = new double[n];
^
exemple.cpp: In constructor ‘vecteur::vecteur(int)’:
exemple.cpp:13:1: warning: extended initializer lists only available with -std=c++11 or -std=gnu++11
{
^
exemple.cpp:14:3: error: ‘table’ was not declared in this scope
table = new double[n];
^
exemple.cpp:14:24: error: expected ‘}’ before ‘;’ token
table = new double[n];
^
exemple.cpp:14:24: error: cannot convert ‘<brace-enclosed initializer list>’ to ‘int’ in initialization
exemple.cpp:14:24: error: expected ‘{’ before ‘;’ token
exemple.cpp: At global scope:
exemple.cpp:15:1: error: expected declaration before ‘}’ token
}


Je ne sais pas l'aranger parce que moi non plus je ne comprend pas pourquoi tab et pas ref?
voici le nouveau fichier .h

#include<iostream>
using namespace std;
typedef double R;//définition du corps
class vecteur
{
 private:
  int n;//taille
  R *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
  void affiche();//déclaration de la fonction affiche
};

et merci, merci beaucoup pour votre patience, si ce n'était pas vous j'aurai fini par abandonné tellement j'étais embrouillée.

[Jack]

exemple.cpp:7:3: error: ‘tab’ was not declared in this scope
tab = new double[n];

C'est ce que je craignais, tu cherches trop à recopier sans comprendre le fond. J'avais dû mettre tab dans mon exemple, parce que tab me semblait un identificateur plus parlant, mais le tien s'appelle v. Remplace tab par v et ça devrait aller mieux.

Quel est l'intérêt de

typedef double R;//définition du corpsPersonnellement, je préfère voir
double *v;
plutôt que
R* v;

[invite389df8bf]

non, non justement j'essaye à tout prix d'éviter de faire du copier coller sans comprendre. Quand vous me donnez une expression j'ssaye de la comprendre, ainsi je la mémorise mieux, et je comprend ce qui se fait. J'arange tout ca et je reviens.

[invite389df8bf]

Voici le nouveau 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
  void affiche();//déclaration de la fonction affiche
};

et voici 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 n):n
{
  v = new double[n];
}
main()
{

  std::cout "affichier q.c.q";
}

et il m'envoie l'erreur suivante:

exemple.cpp: In constructor ‘vecteur::vecteur(int)’:
exemple.cpp:13:1: warning: extended initializer lists only available with -std=c++11 or -std=gnu++11
{
^
exemple.cpp:14:20: error: expected ‘}’ before ‘;’ token
v = new double[n];
^
exemple.cpp:14:20: error: invalid conversion from ‘double*’ to ‘int’ [-fpermissive]
exemple.cpp:14:20: error: expected ‘{’ before ‘;’ token
exemple.cpp: At global scope:
exemple.cpp:15:1: error: expected declaration before ‘}’ token
}
^

Bon, il a un problème avec la définition du constructeur avec argument.
1- Mais un constructeur avec argument, c'est quoi? C'est un vecteur à n composantes, c'est tout. Non? Qu'est ce qu'il faut ajouter à sa définition s'il vous plaît?

2- Pour définir le constructructeur de copie. Un constructeur de copie, c'est quoi? C'est une fonction qui crée un objet de la classe qui a les même attributs qu'un objet déjà crée, donc ici, si on a déjà un vecteur, et qu'on appelle la méthode de constructeur de copie, on va créer un autre vecteur qui a les mêmes attributs, donc la même taille et les mêmes composantes que l'autre.
2-a- je ne vois pas à quoi ca sert, on travail directement avec le vecteur lui même, pourquoi travailler avec sa copie?
2- pour le définir, il faut préciser sa taille qui est n, et il faut lui allouer la mémoire nécessaire puis recopier toutes les composantes. Dans la syntaxe de la définition
on commence par n(ref.n)--> ca veut dire que sa taille est de n, comme l'objet de réference ref.
v=new double[n]-> on alloue un espace pour un vecteur de n composante, et on le nomme v.
v[i]=ref.v[i]--> on recopie les composantes de ref(ref.v[i]) dans le vecteur r.
Voilà, je pense que j'ai bien compris le constructeur de copie.
Il me reste le constructeur avec argument, pouvez vous s'il vous plaît me dire comment arranger sa définition? Je vous remercie par avance.

[invite389df8bf]

***suite***
voici 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 n):n
{
 v = new double[n];
}
main()
{

  std::cout<< "affichier q.c.q";
}

[Jack]

non, non justement j'essaye à tout prix d'éviter de faire du copier coller sans comprendre. Quand vous me donnez une expression j'ssaye de la comprendre, ainsi je la mémorise mieux, et je comprend ce qui se fait

Je vois bien que tu te donnes du mal et c'est pour cela que je ne t'ai pas laissé tomber. Je vois que tu as reçu de l'aide d'autres participants, et c'est bien comme cela.

exemple.cpp: In constructor ‘vecteur::vecteur(int)’:
exemple.cpp:13:1: warning: extended initializer lists only available with -std=c++11 or -std=gnu++11
{

Je ne connais pas ton compilateur, mais je pense qu'il suffit d'ajouter les options indiquées dans le message.
Au pire, tu te passes de la liste d'initialisation et tu fais les affectations dans le corps du constructeur.

2- Pour définir le constructructeur de copie. Un constructeur de copie, c'est quoi? C'est une fonction qui crée un objet de la classe qui a les même attributs qu'un objet déjà crée

Pas forcément. D'ailleurs dans cas où tu ne créerais pas de constructeur de copie, le compilateur en créera un qui effectuera une copie exacte de celui dont tu as fourni la référence. dans ton cas c'est insuffisant car il y aurait copie du pointeur sur le tableau et en instanciant un vecteur par copie, le second partagerait le même tableau que l'original.
Il faut au contraire éviter cela en la zone mémoire contenant les données du tableau. Ainsi les 2 pointeurs ne seront plus égaux et pointeront chacun sur leur propre tableau.

vecteur::vecteur(int n):n

Si tu donnes le même nom au paramètre du constructeur et à l'attribut à initialiser, il va falloir utiliser le pointeur this. Exemple (sans liste d'initialisation):

vecteur::vecteur(int n)
{
   this->n = n;
   v = new double[n];   // personnellement, je mettrais le contenu du tableau à 0
}

Le mieux serait un constructeur avec 2 arguments: un pour la taille et l'autre pour la valeur à initialiser dans le tableau et dont la valeur par défaut serait égale à 0.

Dans le .h:

vecteur(int nb=0, double val=0);

Dans le .cpp

vecteur::vecteur(int nb, double val)
{
   n = nb;
   if (nb == 0)
      v = NULL; // ou nullptr si ton compilateur le reconnait
   else
   {
      v = new double[n];
      for (unsigned i=0; i<n; i++)
         v[i] = val;
   }
}

comme ça dans ton main tu pourras instancier:

vecteur v1(); // tableau vide
vecteur v2(5); // un tableau de 5 double valant 0
vecteur v3(8,2.5); tableau de 8 double valant 2.5

Bon, c'est non testé. A toi de vérifier et éventuellement corriger

[invite389df8bf]

Merci beaucoup, la compilation et l'execution marchent très bien avec un tableau vide.Mais quand j'ai essayé de déclaré un vecteur v1(2), il m'a donné des erreur, je me suis donc rendu compte que j'ai oublié de définir le destructeur. J'ai donc rajouté sa définition, et la compilation marche très bien. Après ça, j'ai rajouter cout et cin pour afficher et faire rentrer les composantes du vecteur, et là il m'affiche un nombre intérminable d'erreurs.
Voici 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];
}
vecteur::vecteur(int n)
{
  this->n = n;
  v = new double[n];
}

vecteur::~vecteur()
{}

main()
{
  vecteur v1(2);
   std:: cout<<"les composantes du vecteur v1 sont";
   std::cin>>v1(2);
}

et voici l'erreur
error: no match for call to ‘(vecteur) (int)’
std::cin>>v1(2);
^
puis, j'ai essayé de remplacer les () par [], dans std::con>>v1[2], et là il me dit ceci:
error: no match for ‘operator[]’ (operand types are ‘vecteur’ and ‘int’)
std::cin>>v1[2];
^

Comment aranger s'il vous plait? S'il faut définir l'opérateur [] comment le définir s'il vous plaît? De manière logique. Je vous remercie par avance.

[Jack]

C'est normal, il faut redéfinir les opérateurs >>, << et []
Comment veux-tu que le compilateur devine ce qu'il doit faire de ces opérateurs avec ta classe?

[invite1c6b0acc]

Bonjour,

Une possibilité, pour ne pas avoir à redéfinir les opérateurs >>, << et [] c'est d'avoir accès aux valeurs des composantes de ton vecteur.
Tu les a déclaré "private" ce qui est très bien : on ne risque pas de les modifier par accident, mais du coup on ne peut pas les connaître.
Une solution simple c'est d'écrire une méthode qui te donne la valeur des composantes.
Par exemple :

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

Comme ça tu ne risques toujours pas de modifier une composante, mais tu peux l'afficher, t'en servir dans un calcul, etc ...

Sinon, pour répondre à une question que tu as posée plus haut, le constructeur de copie sert quand tu feras quelque chose comme :

Vecteur v1;
Vecteur v2;
Vecteur v3;

... (traitement qui donne des valeurs à v1 et v2)

v3 = v1 + v2;

la ligne v3 = v1+ v2; va d'abord lancer l'opérateur d'addition pour calculer v1+v2 et ensuite lancer le constructeur de copie pour mettre le résultat dans v3.
C'est très confortable : tu pourras te servir du type "Vecteur" comme tu te servirais du type "int" ou "double".

[invite389df8bf]

Merci pour cette idée.
Donc, j'ai déclaré cette fonction dans le fichier.h que voici

#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);
  void affiche();//déclaration de la fonction affiche
};

et après, je l'ai définie dans le fichier .cpp que voici

#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()
{}


//définition de la fonction qui affiche les composantes
double composante (int i)
{
    return v[i];
}

main()
{
  vecteur v[4];
   std:: cout<<"les composantes du vecteur";
}

mais il m'envoie l'erreur suivante:
exemple.cpp: In function ‘double composante(int)’:
exemple.cpp:24:12: error: ‘v’ was not declared in this scope
return v[i];
^

je ne comprend pas, pourtant v est un élément de la classe vecteur. Comment utiliser alors cette fonction composante? Je vous remercie par avance.

[invite1c6b0acc]

C'est parce que tu ne dis pas que c'est la méthode composante de ta classe vecteur : le compilateur "croit" que c'est une fonction différente, indépendante de toute classe.
Il faut la déclarer en précisant vecteur::

double vecteur::composante (int)

[pm42]

C'est vecteur::composante et pas composante seulement dans la déclaration...

Chercher un peu toi même serait une bonne chose ceci dit.

EDIT: grillé par Chanur

[invite389df8bf]

****Suite****
En utilisant un document, j'ai essayé ceci:
le fichier.h
[CODE]
#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
int& operator[] (unsigned i);
void affiche();//déclaration de la fonction affiche
};
[CODE]
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];
}
vecteur::vecteur(int n)
{
  this->n = n;
  v = new double[n];
}

vecteur::~vecteur()
{}

int& operator[] (unsigned i)  
    {  
        if (i > 99)  
            error();  
        return v[i];  
    } 
main()
{
  vecteur v[4];
   std:: cout<<"les composantes du vecteur";
}

et ca me donne aussi une erreur. L'erreur est la suivante:

exemple.cpp:20:28: error: ‘int& operator[](unsigned int)’ must be a nonstatic member function
int& operator[] (unsigned i)
^
Je ne comprend pas. Comment aranger de manière simple et logique? S'il vous plaît.

[invite389df8bf]

ok, j'ai envoyé en même temps que vous avant d'avoir lu vos remarques.
je cherche. merci beaucoup

[invite389df8bf]

Oui, vous avez raison, on doit préciser que la fonction reste dans le cadre de la classe, et cela en utilisant l'opérateur de portée "::" . et en messant le type avant le nom de la classe.

[invite389df8bf]

Pour l'utiliser, j'ai essayé plusieurs choses qui n'ont pas marché. Voici la dérnière version de 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];
}
vecteur::vecteur(int n)
{
  this->n = n;
  v = new double[n];
}

vecteur::~vecteur()
{}

double vecteur::composante(int i)
{
  return v[i];
}
main()
{
  int i;
  vecteur v[4];
   std:: cout<<"les composantes du vecteur v sont";
   for(i=0;i<4;i++)
     std::cin>>double vecteur::composante(i);    
}

et il me renvoie l'erreur
exemple.cpp: In function ‘int main()’:
exemple.cpp:30:28: error: ‘composante’ was not declared in this scope
std::cin>>composante(i);
^
Comment l'appeller correctement? Normalement il suffit d'écrire nom de de la fonction(paramètre). Je vous remercie par avance.

[invite389df8bf]

Pardon, voici mon programme

Pour l'utiliser, j'ai essayé plusieurs choses qui n'ont pas marché. Voici la dérnière version de 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];
}
vecteur::vecteur(int n)
{
  this->n = n;
  v = new double[n];
}

vecteur::~vecteur()
{}

double vecteur::composante(int i)
{
  return v[i];
}
main()
{
  int i;
  vecteur v[4];
  
   for(i=0;i<4;i++)
         
cout<<"v=";v.composante(i);cout<<"/n";
}

et il me renvoie l'erreur

exemple.cpp: In function ‘int main()’:
exemple.cpp:28:24: error: request for member ‘composante’ in ‘v’, which is of non-class type ‘vecteur [4]’
std::cout<<"v=";v.composante(i );cout<<"/n";
^

Comment l'appeller correctement? Normalement il suffit d'écrire élement.nom de la fonction(paramètre). Je vous remercie par avance.

[invite1c6b0acc]

Oui, mais v n'est pas un vecteur, c'est un tableau de 4 vecteurs ...

[invite389df8bf]

Tu as raison, il faut mettre seulement vecteur v.
Ca marche bien, mais à l'exécution, quand je met ./a.out, il me dit: Erreur de segmentation (core dumped).
Je ne comprend pas cette exempression.
Par ailleurs, ce que je souhaite, c'est lui faire rentrer les valeurs de chaque composante, std::cin>>v.composante(i); doit faire l'affaire. Mais quand je lui écrit ca:

#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];
}
main()
{
  int i;
  vecteur v;
  for(i=0;i<4;i++)
    {
     std::cout<<"v=";
     std::cin>>v.composante(i);
    }
    
}

il affiche un grand nombre d'erreurs. Comment aranger ca pour lui faire rentrer les composantes (une par une, ou bien tout le vecteur à la fois si c'est possible)? Je vous remercie par avance.

[invite389df8bf]

Voilà donc mon dernier 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];
}
vecteur::vecteur(int n)
{
  this->n = n;
  v = new double[n];
}

vecteur::~vecteur()
{}

double vecteur::composante(int i)
{
  return v[i];
}
main()
{
  int i;
  vecteur v;
  std::cout<<"v=";cout<<"\n";
  for(i=0;i<4;i++) std::cin>>v.composante(i);
  
    
}

il y'a un nombre considérable d'erreur dûes à l'instruction

for(i=0;i<4;i++) std::cin>>v.composante(i);

l'objectif étant de faire rentrer les composantes du vecteur v (une par une ou bien toutes à la fois, je veux bien connaître les deux syntaxes. Je n'arrive pas à aranger, pourtat l'appel de la fonction se fait bien par "elm de la classe. nom de la fonction (argument de la fonction). Je vous remercie par avance.

[invite1c6b0acc]

Je vais d'abord revenir sur le début de ton message précédent :
"erreur de segmentation" signifie que tu fais une opération illicite sur des adresses. Par exemple utiliser un pointeur non initialisé ou écrire dans une zone mémoire qu'on a libérée, ce genre de choses.
"core dumped" signifie que le système a créé un fichier "core" qui contient l'intégralité du process qui s'est planté, tel qu'il était au moment du plantage, y compris la valeur de toutes les variables, le contenu de toutes les zones allouées, l'instruction qui a provoqué le plantage et la pile d'appel des fonctions au moment du plantage. C'est extrêmement pratique. Ce fichier se lit avec le debugger (gdb, je présume puisque tu semble être sous Linux). On peut paramétrer le fait que le fichier core soit ou pas produit : s'il n'y en a pas c'est que ton paramétrage l'interdit. (Voir la commande shell ulimit).

Je tenais à t'en parler pour t'inciter à apprendre à te servir du debugger. C'est un outils très puissant pour comprendre ce que fait un programme. Ça peut être un peu lourd à apprendre, mais ça en vaut la peine.

Maintenant, tu as bien compris que l'erreur se produisant parce que tu n'avais pas initialisé ton vecteur : le constructeur par défaut, qui est lancé à la ligne "Vecteur v;" donne à v la valeur NULL qui est faite exprès pour être un pointeur invalide (il est mille fois préférable qu'un programme plante franchement plutôt qu'il fasse semblant de fonctionner correctement). Du coup l'instruction return v[i]; de la méthode "composante" est forcée de planter.
Même si tu initialise v avec le constructeur qui prend en paramètres le nombre de composants, tu ne peut toujours pas modifier leurs valeurs.

Voyons les solutions possibles.
D'abord, la réponse générale : "comment faire pour que ma classe fasse ça ?" a la réponse générale "écrire une méthode qui le fasse".
Plusieurs possibilités :
- un constructeur auquel on donne les valeurs des composantes. Pas évident puisque le nombre de valeurs est variable (on peut faire des fonctions ayant un nombre variable d'arguments, mais ça nous entraînerait un peu loin et ça présente le défaut que le compilateur ne peux plus vérifier que le nombre et le type d'arguments sont corrects).
- autoriser l'accès public à v. Dommage de supprimer cette protection qui est en général souhaitable.
- une méthode qui retourne l'adresse "v" pour pouvoir y écrire (même si v est "private", si on en connaît la valeur, c'est à dire l'adresse de la première composante, on peut écrire à cette adresse et aux adresses suivantes). On ne risque pas de désallouer "v" par inadvertance, mais on peut modifier comme on veut les composantes d'un vecteur. Ça se discute, surtout parce que rien n'empêche de modifier la 253ème composante d'un vecteur qui n'en aurait que 4 : désastre garanti.
- une méthode, symétrique de "composante", à laquelle on donne un indice et une valeur et qui va la placer au bon endroit dans le tableau v.
Elle peut commencer par vérifier que l'indice donné est bien compris entre 0 et n-1 et donner un message d'erreur bien propre si ce n'est pas le cas (au passage, ce ne serait pas une mauvaise idée de faire le même contrôle dans la méthode "composante").

Il me semble que c'est la dernière qui correspond le mieux à ce que tu veux, mais elles ont toutes leurs avantages et on a le choix.
Au boulot !

[invite389df8bf]

Voici comment je définit la fonction symétrique qui place des valeurs dans le vecteur v

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

dans la fonction main, Quand on déclare v par vecteur v, il y'a le constructeur par défaut qui intervient automatiquement, et qui initialise les composantes du vecteurs par 0. Ma question est: comment interviennent les fonctions sym et composante en même temps dans le main?
Voici je que je pense. La fonction "composante" intervient en premier, et on l'appelle par "v.composante(i)", et après on lui affecte une valeur val, donc on écrit
v.composante=v.sym
je ne sais pas si ca tien la route. Comment l'aranger s'il vous plaît? de manière logique. Merci beaucoup.

[invite0bbe92c0]

Voici comment je définit la fonction symétrique qui place des valeurs dans le vecteur v

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

.

en dehors du fait que ce code ne peut pas compiler - à cause de if (i>=) n -, il ne sert à rien : on ne voit pas l’intérêt d'écraser la valeur passée en paramètre par une autre, pour ne pas l'utiliser ensuite.

[invite389df8bf]

désolée, j'ai fait une erreur de frappe pour le code.