Discussion :

[hinaneee]

Bon, j'ai réecris mon programme

fichier.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
#include<iostream>
 
//template<typename Real, int dim> class Vector; 
 
//template<typename Real, int dim> 
//std::ostream& operator<<(std::ostream&, Vector<Real,int> const&);
 
template <typename Real>
class vector
{
 private:
  int dim;//taille
  Real *v;//pointer les composantes
 public:
  vector(int nb=0, Real val=0);//déclaration d'un constructeur avec argument
  vector(vecteur const& v);//déclaration d'un constructeur de copie
  ~vector();//déstructeur
  Real& operator [] (int rang);//Déclaration de l'opérateur[]
  vector& operator = (const vector&);//Déclaration de l'opérateur =
  vector operator * (Real scalar); //Déclaration de l'opérateur *
  vector operator + (const vector&);//Déclaration de l'opérateur +
  vector operator - (const vector&);//Déclaration de l'opérateur -
  Real vector:: norme (const vector&, int dim) const;
  void affiche();   
};
 
 
 
//Définition du constructeur de copie
vector::vector(const vecteur& ref): n(ref.dim)
{
  v = new Real[dim];
  for(int i=0; i<dim;i++)
    v[i]=ref.v[i];
}
 
//Définition du constructeur avec argument
vector::vector(int nb, Real val)
{
   dim = nb;
   if (nb == 0)
      v = NULL; 
   else
   {
      v = new Real[dim];
      for (int i=0; i<dim; i++)
         v[i] = val;
   }
}
 
//Définition du destructeur
vector::~vector()
{}
 
//Définition de []
Real& vector::operator[](int rang)
{
  return v[rang]; 
}
 
//Définition de =
 
vector &vector::operator=(const vecteur &a)
{
  for(int i=0;i<dim;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}
 
 
//Définition de +
vector vector:: operator + (const vecteur &a)
{
vecteur d(dim);
for (int i=0;i<n;i++)
d.v[i]=v[i]+a.v[i];
return d;
}
 
//Définition de *
vector vector:: operator*(Real  d)
{
for(int i=0;i<dim;i++)
v[i]=d*v[i];
return *this;
}
 
 
//Définition de la fonction norme
Real vector:: norme (const vecteur&, int dim) const
{
Real p=;
 for (int i=0; i<dim; i++)
  {
   p=v[i] * v[i] + p;
  }
 return sqrt(p);
} 
 
 
 
 
//Déclaration de la fonction affiche
void vector::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<dim;i++)
{
std::cout<<v[i]<<std::endl;
}
std::cout<< "---fin---"<<std::endl;
}

fichier.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
#include <iostream>
#include "Vector.h"
#include <cmath>
#include <fstream>
using namespace std;
 
 
int main()
 
{
 
return 0 ;
 
}

Et il me renvoie les erreurs suvantes:

error: expected ‘)’ before ‘const’
vector(vecteur const& v);//déclaration d'un constructeur de copie
^
Vector.h:23:8: error: extra qualification ‘vector<Real>::’ on member ‘norme’ [-fpermissive]
Real vector:: norme (const vector&, int dim) const;
^
Vector.h:23:48: error: explicit specialization of ‘Real vector<Real>::norme(const vector<Real>&, int) const’ must be introduced by ‘template <>’
Real vector:: norme (const vector&, int dim) const;
^
Vector.h:30:1: error: invalid use of template-name ‘vector’ without an argument list
vector::vector(const vecteur& ref): n(ref.dim)
^
Vector.h:38:1: error: invalid use of template-name ‘vector’ without an argument list
vector::vector(int nb, Real val)
^
Vector.h:52:1: error: invalid use of template-name ‘vector’ without an argument list
vector::~vector()
^
Vector.h:56:1: error: ‘Real’ does not name a type
Real& vector::operator[](int rang)
^
Vector.h:63:1: error: invalid use of template-name ‘vector’ without an argument list
vector &vector::operator=(const vecteur &a)
^
Vector.h:74:1: error: invalid use of template-name ‘vector’ without an argument list
vector vector:: operator + (const vecteur &a)
^
Vector.h:83:1: error: invalid use of template-name ‘vector’ without an argument list
vector vector:: operator*(Real d)
^
Vector.h:92:1: error: ‘Real’ does not name a type
Real vector:: norme (const vecteur&, int dim) const
^
Vector.h:106:6: error: ‘template<class Real> class vector’ used without template parameters
void vector::affiche()
^
Vector.h: In function ‘void affiche()’:
Vector.h:109:15: error: ‘dim’ was not declared in this scope
for(int i=0;i<dim;i++)
^
Vector.h:111:12: error: ‘v’ was not declared in this scope
std::cout<<v[i]<<std::endl;



Indiquez moi comment le corriger s'il vous plaît pour que je comprenne une bonne fois pour toute. Je vous remercie par avance.

[bacelar]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

vector::vector(const vecteur& ref): n(ref.dim)

vecteur != vector

[ternel]

Et toutes tes définitions "externes à la template de classe" sont à déclarer comme telles:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
template <typename Real>
class vector
{
 private:
  int dim;//taille
  Real *v;//pointer les composantes
 public:
  vector(int nb=0, Real val=0);//déclaration d'un constructeur avec argument
//...
};
 
 
//Définition du constructeur avec argument
template <typename Real>
inline vector::vector(int nb, Real val) : dim(nb), v(nb == 0 ? nullptr : new Real[dim]) {
    for (int i=0; i<dim; i++) v[i] = val;
}

Je t'invite à réfléchir à si un vecteur peut changer de dimension.
Si ce n'est pas le cas, alors tu as effectivement intérêt:

• dans un premier temps, à rendre dim constant
• dans un second, le remplacer par un parametre template, et une fonction: constexpr size_type dim() {return Dim;}.

L'objectif, c'est d'avoir plusieurs types incompatibles entre eux, sauf quand tu le veux vraiment.

[hinaneee]

Merci beaucoup, j'avais fait trop d'erreurs de syntaxe. J'ai corrigé toutes les erreurs et ca marche. Merci.

[ternel]

Pour l'instant, ca compile, mais il reste encore les possibles problèmes de mémoire, la sureté, pouvoir compiler 2*v.
Bon courage.

Ca me fait penser qu'il faudrait que je publie ma petite bibliothèque d'objets mathématiques.

[hinaneee]

leternel, s'il te plaît expliques moi comment régler les problèmes de sureté et de mémoire?
Autre question, quand je vois des classe, il y'en a où les attributs sont déclarée comme private, et il y'a des cas où l'on déclare les attributs comme protected. Pouvez vous me dire la différence entre les deux et quand est-ce qu'on utilise l'un ou l'autre?
Je vous remercie par avance.

[bacelar]

Il faut absolument que vous lisiez un cours de C++ (un vrai) avant de continuer.
Sinon, vous allez droit dans le mur.

[hinaneee]

Le problème est que je suis bien entrain de lire un cours en C++, mais je ne comprend pas ce qu'il veut dire par "problème de mémoire et de sureté", donc je pose la question, s'il est possible de me répondre.
Merci par avance.

[ternel]

Il faut voir le problème d'un autre point de vue, alors.

En C++, comme dans beaucoup de langage, on a des outils de plusieurs niveaux d'abstraction.

Par exemple, un int est un type primitif: il n'a aucun controle, il est "bassement matériel", et n'a aucune signification concrête.
C'est le nom de la variable, et son utilisation, qui lui en donne.

Ainsi, int age_capitaine et int clous sont deux entiers qui n'ont apparamment rien à voir.
Mais même avec de tels noms, on ne sait toujours pas si l'age du capitaine est en jours, en mois ou en années, ou si les clous sont comptés par pièce ou par lot.
Pour les clous, il y a une solution logique, 1 = 1 clou. Mais pas pour l'age.

Les classes (entre autres choses) permettent de définir des types plus explicites.
Ainsi, une classe Age permettrait d'exprimer explicitement la nature de age_capitaine.
Il suffit alors de doter la classe de fonctions ayant un sens précis.
Et en prime, en ayant un type différent de int, une expression comme age_capitaine + clous n'a plus de sens, et sera rejeté par le compilateur.

L'intérêt d'une classe est d'apporter plus de maitrise de ce qui est possible, en ajoutant du sens. On parle de sémantique.

Cela dit, toutes les classes n'ont pas non plus le même usage.
Certaines sont des outils pour en écrire d'autres.
Ainsi, la STL contient un certain nombre de classes (enfin, templates de classes) gérant des groupements de choses: liste, ensemble, tableaux (vector et array), table d'associations (map et consort).
Mais aussi des classes mathématiques: complex et la série des random.

Ce sont d'excellents outils pour le développeur, mais n'intéresse absoluement pas l'utilisateur du programme.
Ils sont moins "bassement matériels" qu'un int (ce qu'on dit aussi plus abstraits ou de plus haut niveau), mais encore techniques.

On opposera ces classes-ci à d'autres plus utiles à l'utilisateur de l'application, les classes dites métier.
Par exemple, Marin et Navire, dans un programme de gestion pour une compagnie maritime, ou Objet et Caisse pour un gestionnaire d'inventaire.

Chaque classe possède (ou devrait posséder) un unique objectif (Single Responsability), et ne s'occuper que de celui-ci.
Une [c]std::list[c] a pour objectif "être une séquence d'objets du même type, modifiable rapidement".
Un std::vector se présente comme "une séquence d'objets du même type, stoqués de manière compacte".

La sureté d'une classe est sa qualité à assurer son objectif.
Ta classe de vecteur (au sens mathématique) doit expliciter ce qu'elle garantit, et comment (échec de la compilation ou plantage à l'exécution ou souplesse à l'exécution).
La cardinalité du vecteur est une caractéristique si importante qu'il est intéressante de la fixer dans le type lui-même, plutot que dans la variable.
C'est la raison pour laquelle tu as vu la taille parmi les paramètres templates. En procédant ainsi, il devient impossible de faire des opérations mathématiques entre vecteurs de cardinalités incohérentes. Du moins, il devient possible d'empêcher la compilation de telles expressions, car un vecteur<3, double> n'est pas du même type qu'un vecteur<4, double>.

Concrêtement, ton vecteur est exactement représentable par un std::array<4, int>. Tu peux donc choisir soit d'en hériter de manière private, soit d'en contenir un.
Je te conseille cette dernière solution, car ton vecteur possède l'aspect, mais pas la signification d'un std::array.
(et aussi, parce que la STL n'est pas pensée pour l'héritage)


Quant à ta question sur la gestion de la mémoire, le problème est délicat à traiter, et se résume s'assurer qu'on sait toujours répondre oui aux deux questions suivantes:

1. La mémoire allouée est-elle libérée une et une seule fois?
2. La mémoire est elle allouée (au sens non libérée) quand elle est lue?

C'est une question si délicate que le langage à créé des types dédiés: les références, les unique_ptr, etc, mais aussi toutes les collections.

[bountykiler]

vecteur != vector

Oui, et je pense que c'est bien là la base du problème.
Si j'ai bien compris, tu essaie d'implémenter une classe vecteur = objet mathématique.
Or, je pense que la majorité de la doc que tu trouve parles de vector. Or en C++, la classe vector représente en fait un tableau contenant différentes valeurs d'un même type.
Cela est donc très différents de ce que tu veux.

Maintenant, si j'ai 1 conseil à te donner c'est de commencer par te poser et partir de ce que tu entends par vecteur.
Commence par essayer de déterminer de quoi se compose un vecteur. Cela devrait te permettre de déterminer les champs de ta classe.
Ensuite, essaie de voir quelles sont les opérations que que tu veux effectuer sur ton objet. Cela devrait te donner les méthodes de ta classe.

Une fois que tu auras cela, tu pourra commencer à avancer et à coder.

(et accessoirement, oubli les notions de templates, de sureté et de problèmes de mémoire pour le moment. C'est important certes, mais commençons par le début).