La surcharge d'opérateurs

**ben54120** · 04/10/2009, 10h43

Bonjour à tous.

Voila, donc j'ai un petit travail à effectuer ce week end, et jusqu'à maintenant je galère énormément, c'est pourquoi j'ai décidé de venir poster ici.

Je dois, à partir d'une classe vecteur, surcharger beaucoup beaucoup d'opérateurs (= += ++ -- << >> == ....). Le problème c'est que je suis totalement débutant en C++ et que je n'ai jamais vu ce genre de surcharge ! Les cours reçus sont vraiment insuffisants puisqu'on a fait que parler des opérateurs, on a pas eu de réel exemple concret. En plus les infos sur internet ne correspondent pas totalement à mon problème (incrémenter un nombre, OK, mais incrémenter un vecteur...), du coup ça m'embrouille plus que tout le reste !

Donc je voulais deja vous demander ce que vous pensiez de mes opérateurs que j'ai deja surchargés. Pour indication ma classe vecteur à une dimension est constituée d'une taille et d'un tableau pointant sur des entiers (rien que ça j'arrive pas trop à comprendre à quoi ça sert dans le cas de vecteurs à UNE dimension...). En effet, le prof voulait absolument qu'on crée un tableau et un taille en attributs, personnellement je n'ai pas du tout compris car moi j'aurais pas fait comme ça, du moins pas pour des vecteurs à une dimension...Le pauvre a essayé de me faire comprendre mais il a vite abandonné, ce qui me rend encore plus seul au monde ! Voici mon code :

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
 
// Acces aux elements
  int& vecteur::operator[](const int rang) {
    return tab[rang];
  }
 
// affectation : =(vecteur), =(int)
  vecteur& vecteur::operator=(const vecteur& v) {
    vecteur tmp;
    tmp.taille = v.taille;
    tmp.tab = v.tab;
    return tmp;
  }
  vecteur& vecteur::operator=(const int nb) {
    vecteur tmp;
    tmp.taille = 1;
    tmp.tab[0] = nb;
    return tmp;
  }
 
// incrementation/decr. : ++, ++(int), --
  vecteur& vecteur::operator++() {
    taille++;
    return (*this);
  }
 
  vecteur vecteur::operator++(const int i) {
    vecteur v = *this;
    taille++;
    return v;
  }
 
  vecteur& vecteur::operator--() {
    taille--;
    return (*this);
  }

Ensuite, j'ai quelques petites questions justement sur ces opérateurs car le but n'est bien évidemment pas que vous me donniez la réponse sans explication, mais j'aimerais surtout comprendre afin de pouvoir le refaire moi même par la suite !
1) L'opérateur d'affectation = : Dans mon cas, on peut dire qu'il retourne un nouvel objet ayant les valeurs voulues. Mais le truc c'est qu'il n'a changé en rien la valeur de l'objet courant this ??
2) J'ai du mal à saisir la différence entre ++() et ++(int) malgrès ce que j'ai lu sur le net si ce n'est que l'un retourne la valeur incrémentée, l'autre non, mais alors à quoi ça sert ?
3) Comment incrémenter/décrementer mes vecteurs, si ce n'est en changeant leur taille ?

Merci de votre aide et bonne fin de week end ;-)

**ben54120** · 04/10/2009, 11h17

Je me permets le double post pour rajouter une question.

Mes opérateurs d'affectation = ne seraient-ils pas plus justes en les écrivant comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
  vecteur& vecteur::operator=(const vecteur& v) {
    taille = v.taille;
    tab = v.tab;
    return (*this);
  }
  vecteur& vecteur::operator=(const int nb) {
    taille = 1;
    tab[0] = nb;
    return (*this);
  }

En exécutant, j'obtient le bon résultat et ensuite j'ai un truc "glibc detected....backtrace :....memory map:..." qui s'affiche avec tout des adresses mémoires, qu'est-ce que c'est ?
Voici mon main (ou plutôt celui fourni par mon prof) :

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
 
#include <iostream>
 
 
 
// Include de l'application
 
#include "Vecteur.h"
 
 
using namespace std;
 
 
int main(int argc, char **argv)
 
{
 
 
 
	cout << "PROGRAMME DE TEST" << endl;
 
 
 
	// Constructeurs
 
	vecteur v1(3);
 
	vecteur v2 = v1;
 
	vecteur v3;
 
 
 
	v1[0] = 2;
 
	v1[1] = 4;
 
	v1[2] = 6;
        v1++;
        v1[3] = 8;
 
 
	cout << "v1 :	" << v1 << endl;
 
 
 
	v2 = v1;
 
	cout << "v2 = v1 :	" << v2 << endl;
 
 
 
//	v2++;
 
//	cout << "v2++ :	" << v2 << endl;
 
 
 
//	v3 = v1 + v2;
 
//	cout << "v3 = v1 + v2 :	" << v3 << endl;
 
 
 
 
 
	cout << "SORTIE TEST" << endl;
 
}

**Goten** · 04/10/2009, 11h22

1) l'op= doit retourner une ref sur *this. Pas un temporaire (comme tu l'as dis ça n'aurait aucun sens).
Renseigne toi sur l'idiome copy'n'swap pour implémenter l'op= sous la bonne forme.

2) Faut d'abord comprendre l'utilisation avant de surcharger : il y'a deux opérateur ++ un postfixé et un préfixé. l'opérateur préfixé renvoie une référence sur *this, l'incrémentation est donc "de suite valable".
L'opérateur postfixé quand à lui retourne par valeur une copie de *this, et qui n'a donc pas subit l'incrémentation. (en français dans le texte c'est pas facile à expliquer donc regarde ce bout de code

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int main()
{
    int i = 0;
 
    std::cout << i++ << std::endl; // on travaille sur une copie non incrémenté
    std::cout << ++i << std::endl; // on travaille sur *this donc l'incrémentation est directement 'valable'
 
    return 0;
}

Maintenant du côté surcharge : operator++() correspond à la version préfixé là où operator++(int) correspond à la version postfix. (pas de const int).

Quand on sait que la version préfixé renvoie une référence on peut facilement déduire que les signatures seront :

Code :

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

1
2
T& operator++(); //prefix
T    operator++(int); //postfix

Et voici le squellette de ces opérateur :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
T& operator++()
{
      //les opérations qui correspondent à l'incrémentation
      return *this;
}
 
T operator++(int)
{
      T bu = *this;
      ++(*this); //on se sert de l'opérateur précédemment défini
      return bu; // on retourne une version non incrémenté d'où le comportement vu au dessus.
}

3) Amha ça n'a pas de sens incrémentée un vecteur...

4) Il faut fournir une version const de l'opérateur []

**ben54120** · 04/10/2009, 11h30

Tout d'abord bonjour et merci d'avoir répondu !

J'ai corrigé les opérateurs d'affectation et d'incrémentation / décrementation et je t'en remercie ;-)

Concernant le point 3, je suis d'accord avec toi...selon moi incrémenter un vecteur dans le sens du proche voudrait probablement dire "Augmenter la taille du tableau" et c'est donc ce que j'ai fait.

Concernant ton point 4, je ne comprends pas : mon operateur [] est deja défini avec un const ??

Et sur mon double post, que penses tu de cette erreur à l'affichage ?

**Goten** · 04/10/2009, 11h52

Ouai au vue du main l'incrémentation veut dire incrémenter la taille. (définitivement ça n'a pas de sens).
Pour la version const non je parle de quelque chose comme ça :

Code :

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

1
2
3
 
const int& operator[](int rang) const;
int& operator[](int rang);

Pour le problème d'affichage, à la suite de detected y'a un message c'est ça qu'est important. Ou alors montre le code entier. (probablement une segfault).

**ben54120** · 04/10/2009, 11h57

ok

Le rendu de l'erreur est :

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
 
PROGRAMME DE TEST
v1 :	4 : �O��(���*�
 
v2 = v1 :	4 : �O��(���*�
 
v1 == v2 ? true
v2++ :	5 : 
 
SORTIE TEST
*** glibc detected *** ./tp: free(): invalid next size (fast): 0x0804c008 ***
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6[0xb7db3604]
/lib/tls/i686/cmov/libc.so.6(cfree+0x96)[0xb7db55b6]
/usr/lib/libstdc++.so.6(_ZdlPv+0x21)[0xb7f96231]
/usr/lib/libstdc++.so.6(_ZdaPv+0x1d)[0xb7f9628d]
./tp[0x8048f02]
./tp[0x8048b47]
/lib/tls/i686/cmov/libc.so.6(__libc_start_main+0xe5)[0xb7d5a775]
./tp[0x80487b1]
======= Memory map: ========
08048000-0804a000 r-xp 00000000 08:06 1554644    /home/ben54120/utbm/cpp_tp1/tp
0804a000-0804b000 r--p 00001000 08:06 1554644    /home/ben54120/utbm/cpp_tp1/tp
0804b000-0804c000 rw-p 00002000 08:06 1554644    /home/ben54120/utbm/cpp_tp1/tp
0804c000-0806d000 rw-p 0804c000 00:00 0          [heap]
b7c00000-b7c21000 rw-p b7c00000 00:00 0 
b7c21000-b7d00000 ---p b7c21000 00:00 0 
b7d43000-b7d44000 rw-p b7d43000 00:00 0 
b7d44000-b7ea0000 r-xp 00000000 08:06 1618872    /lib/tls/i686/cmov/libc-2.9.so
b7ea0000-b7ea1000 ---p 0015c000 08:06 1618872    /lib/tls/i686/cmov/libc-2.9.so
b7ea1000-b7ea3000 r--p 0015c000 08:06 1618872    /lib/tls/i686/cmov/libc-2.9.so
b7ea3000-b7ea4000 rw-p 0015e000 08:06 1618872    /lib/tls/i686/cmov/libc-2.9.so
b7ea4000-b7ea7000 rw-p b7ea4000 00:00 0 
b7ea7000-b7eb4000 r-xp 00000000 08:06 1586300    /lib/libgcc_s.so.1
b7eb4000-b7eb5000 r--p 0000c000 08:06 1586300    /lib/libgcc_s.so.1
b7eb5000-b7eb6000 rw-p 0000d000 08:06 1586300    /lib/libgcc_s.so.1
b7eb6000-b7eb7000 rw-p b7eb6000 00:00 0 
b7eb7000-b7edb000 r-xp 00000000 08:06 1618883    /lib/tls/i686/cmov/libm-2.9.so
b7edb000-b7edc000 r--p 00023000 08:06 1618883    /lib/tls/i686/cmov/libm-2.9.so
b7edc000-b7edd000 rw-p 00024000 08:06 1618883    /lib/tls/i686/cmov/libm-2.9.so
b7edd000-b7fc1000 r-xp 00000000 08:06 245601     /usr/lib/libstdc++.so.6.0.10
b7fc1000-b7fc5000 r--p 000e3000 08:06 245601     /usr/lib/libstdc++.so.6.0.10
b7fc5000-b7fc6000 rw-p 000e7000 08:06 245601     /usr/lib/libstdc++.so.6.0.10
b7fc6000-b7fcc000 rw-p b7fc6000 00:00 0 
b7fde000-b7fe1000 rw-p b7fde000 00:00 0 
b7fe1000-b7fe2000 r-xp b7fe1000 00:00 0          [vdso]
b7fe2000-b7ffe000 r-xp 00000000 08:06 1586147    /lib/ld-2.9.so
b7ffe000-b7fff000 r--p 0001b000 08:06 1586147    /lib/ld-2.9.so
b7fff000-b8000000 rw-p 0001c000 08:06 1586147    /lib/ld-2.9.so
bf95c000-bf971000 rw-p bffeb000 00:00 0          [stack]
Abandon

**Goten** · 04/10/2009, 11h59

Faut vraiment que tu nous donne le code complet avec. ! (on sait même pas par quelle moyen tu stockes les données de ton vecteur

)

**ben54120** · 04/10/2009, 12h02

Bon d'accord, mais ça risque d'être un peu long ^^

Alors j'ai trois fichiers :
Voici le fichier vecteur.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
 
#ifndef VECTEUR_H
 
#define VECTEUR_H
 
//
 
// Type vecteur
 
//
 
#include <iostream>
 
using namespace std;
 
//
 
// Type vecteur de int
 
//
 
class vecteur {
 
 
  private:
    int taille;
  public:
    int* tab;
 
 
  // Constructeurs par defaut(void) , avec la taille du vect.(int), par copie(vecteur&)
 
  public: vecteur();
  public: vecteur(int t);
  public: vecteur(vecteur& v);
 
 
 
  // Destructeur
  public: ~vecteur();
 
 
 
  // Acces a la taille du vecteur
 
  public: int Taille();
 
 
 
  // acces au element []
 
  public: int& operator[](const int rang);
  public: const int& operator[](const int rang) const;
 
 
 
  // affectation : =(vecteur), =(int)
  public: vecteur& operator=(const vecteur& v);
  public: vecteur& operator=(const int nb);
 
 
 
  // incrementation/decr. : ++(void), ++(int), --(void)
  public: vecteur& operator++();
  public: vecteur operator++(int i);
  public: vecteur& operator--();
 
 
 
// op. booleens : ==(vecteur&), <, >, <=, >=
  public: bool operator==(const vecteur& v);
  public: bool operator<(const vecteur& v);
  public: bool operator>(const vecteur& v);
  public: bool operator<=(const vecteur& v);
  public: bool operator>=(const vecteur& v);
 
 
 
// op. binaires : +(vecteur&), -
 
 
 
// produit scalaire: *(vecteur&)
 
 
 
// produit par un scalaire: v * n, n * v
 
//vecteur operator*(int);
 
//friend vecteur operator*(int, vecteur&);
 
 
 
// auto-adition : +=(vecteur&), -=
 
 
 
// Operateurs d'entree/sortie: <<, >>
 
friend ostream& operator<<(ostream& o, vecteur& v);
 
//friend istream& operator>>(istream& i, vecteur& v);
 
 
 
};
 
 
 
#endif // VECTEUR_H

Voici le fichier vecteur.cc :

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
 
// Type vecteur
#include "Vecteur.h"
using namespace std;
 
// Constructeurs
  vecteur::vecteur() {
    taille = 0;
    tab = NULL;
  }
  vecteur::vecteur(int t) {
    taille = t;
    tab = new int[taille];
    for(int i=0;i<taille;i++) {
      tab[i]=0;
    }
  }
  vecteur::vecteur(vecteur& v) {
    taille = v.taille;
    tab = new int[taille];
    for(int i=0;i<taille;i++) {
      tab[i]=v.tab[i];
    }
  }
 
// Destructeur
  vecteur::~vecteur() {
    if(tab) delete[]tab;
  }
 
// Nombre d'elements
  int vecteur::Taille() {
    return taille;
  }
 
 
 
// Acces aux elements
  int& vecteur::operator[](const int rang) {
    return tab[rang];
  }
 
// affectation : =(vecteur), =(int)
  vecteur& vecteur::operator=(const vecteur& v) {
    taille = v.taille;
    tab = v.tab;
    return (*this);
  }
  vecteur& vecteur::operator=(const int nb) {
    taille = 1;
    tab[0] = nb;
    return (*this);
  }
 
// incrementation/decr. : ++, ++(int), --
  vecteur& vecteur::operator++() {
    taille++;
    return (*this);
  }
 
  vecteur vecteur::operator++(int i) {
    vecteur v = *this;
    ++(*this);
    return v;
  }
 
  vecteur& vecteur::operator--() {
    taille--;
    return (*this);
  }
 
 
 
// op. booleens : ==, <, >, <=, >=
  bool vecteur::operator==(const vecteur& v) {
    if(taille == v.taille && tab == v.tab) {
      return true;
    }else{return false;}
  }
  bool vecteur::operator<(const vecteur& v) {
 
  }
  bool vecteur::operator>(const vecteur& v) {
 
  }
  bool vecteur::operator<=(const vecteur& v) {
 
  }
  bool vecteur::operator>=(const vecteur& v) {
 
  }
 
// op. binaires : +, -
 
// produit scalaire : *
 
// produit par un scalaire: n * v, v * n
 
// auto-adition : +=, -=
 
// Operateurs d'entree/sortie: <<, >>
 
  ostream& operator<<(ostream& o, vecteur& a) {
    char str[a.taille];
    for(int i=0; i<a.taille; i++) {
      str[i]=a.tab[i];
    }
    return o << a.taille << " : " << str << endl;
  }
/*
istream& operator>> (istream& i, vecteur& a)
{
	return i;
}*/

Mon but à moi est donc de travailler sur ces 2 premiers fichiers et sur le dernier pour l'affichage :
client.cc

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
 
#include <iostream>
 
 
 
// Include de l'application
 
#include "Vecteur.h"
 
 
using namespace std;
 
 
int main(int argc, char **argv)
 
{
 
 
 
	cout << "PROGRAMME DE TEST" << endl;
 
 
 
	// Constructeurs
 
	vecteur v1(3);
 
	vecteur v2 = v1;
 
	vecteur v3;
 
 
 
	v1[0] = 2;
 
	v1[1] = 4;
 
	v1[2] = 6;
        v1++;
        v1[3] = 8;
 
 
	cout << "v1 :	" << v1 << endl;
 
 
 
	v2 = v1;
 
	cout << "v2 = v1 :	" << v2 << endl;
        if(v1 == v2) cout << "v1 == v2 ? " << "true" << endl;
 
        else cout << "v1 == v2 ? " << "false" << endl;
 
	v2++;
 
	cout << "v2++ :	" << v2 << endl;
 
 
 
//	v3 = v1 + v2;
 
//	cout << "v3 = v1 + v2 :	" << v3 << endl;
 
 
 
 
 
	cout << "SORTIE TEST" << endl;
 
}

Je mets aussi le makefile au cas où...

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
 
# differents types de fichiers 
.SUFFIXES:.o.cc.ln
 
 
#---------------------------------
# INITIALISATION DES VARIABLES 
#---------------------------------
 
# Indiquer le compilateur
CCC = g++
 
# Les chemins ou se trouvent les fichiers a inclure
INCLUDES= /usr/include/c++/4.3.3
#-I/usr/openwin/include
 
# Options de compilation.
CCFLAGS=  ${INCLUDES} -c -Wno-deprecated
 
# Options pour le linker.
LFLAGS=  -o 
 
# Les librairies avec lesquelle on va effectueller l'edition de liens
#LIBS= -L/usr/lib -L /usr/X11R6/lib -lm -L.
 
# Les fichiers sources de l'application
FILES= Client.cc Vecteur.cc
 
#-----------
# LES CIBLES
#-----------
 
tp:  $(FILES:.cc=.o)
	$(CCC) -o tp $(FILES:.cc=.o) ${LIBS}
 
clean:
	/bin/rm $(FILES:.cc=.o) tp
 
#-----------------------------------------------------------------------------
# LES REGLES DE DEPENDANCE. Certaines sont implicites mais je recommande d'en 
# mettre une par fichier source. 
#-----------------------------------------------------------------------------
 
Client.o:Client.cc Vecteur.cc Vecteur.h
Vecteur.o:Vecteur.cc Vecteur.h
 
#---------------------------------
# REGLES DE COMPILATION IMPLICITES
#---------------------------------
 
.cc.o:; ${CCC} ${CCFLAGS} $*.cc

**Médinoc** · 05/10/2009, 11h01

Envoyé par ben54120

(rien que ça j'arrive pas trop à comprendre à quoi ça sert dans le cas de vecteurs à UNE dimension...). En effet, le prof voulait absolument qu'on crée un tableau et un taille en attributs, personnellement je n'ai pas du tout compris car moi j'aurais pas fait comme ça, du moins pas pour des vecteurs à une dimension...

C'est pourtant simple: Si tu ne mémorises pas la taille, tu n'auras aucun moyen de la connaître! Et donc, de vérifier qu'il n'y a pas de débordement...
Au passage, tout ton code présente un énorme défaut: La taille doit, au début et à la fin de toute fonction, refléter exactement celle du buffer alloué! Donc, tu n'as pas le droit de changer la variable membre taille sans réallouer le buffer.

Quant à l'incrémentation, cela dépend si on parle du vecteur ou de son contenu. Imagine une addition de vecteurs, ça peut être:
soit la concaténation des deux vecteurs, bout-à-bout.
soit un vecteur contenant les sommes des valeurs des deux vecteurs en entrée (on peut exiger qu'ils aient la même taille).
Pour l'incrémentation, c'est la même chose: On peut soit incrémenter sa taille, soit incrémenter chacune de ses valeurs.
Il en va de même pour les comparaisons.

L'opérateur d'affectation ne retourne pas un nouvel objet, il modifie l'objet courant et retourne une référence vers lui.
L'opérateur de pré-incrémentation peut retourner directement une référence sur l'objet, et n'a pas besoin d'en faire la moindre copie. L'opérateur de post-incrémentation est obligé de faire une copie de l'objet avant de l'incrémenter, et retourner cette copie par valeur.
Par extension, un type non-copiable ne peut pas avoir de vrai opérateur de post-incrémentation.
Voir plus haut.

**ben54120** · 05/10/2009, 11h22

ok, mais alors à quoi sert ce fameux tableau en attributs ?
C'est ça qui me bloque !

Et pour faire le produit scalaire, du coup je vois vraiment pas comment faire vu que je ne sais pas ce que représente ce tableau...des points ? des vecteurs ? aucune idée

**Médinoc** · 05/10/2009, 11h43

J'ai l'impression que tu confonds le terme vecteur tel qu'il est employé en géométrie ("des coordonnées dans un plan/espace/hyperplan/etc.") et tel qu'il est employé en informatique ("une liste de valeurs, de longueur arbitraire et non fixe").

Il existe peut-être un lien logique entre ces deux termes, une grande théorie unificatrice, mais je ne la connais pas: Je me suis limité à la géométrie dans l'espace, où les vecteurs n'avaient au plus que trois valeurs (pour les trois dimensions).
J'ignore s'il est seulement possible de faire le produit scalaire de deux vecteurs "liste"...

**Mac LAK** · 05/10/2009, 12h44

Envoyé par Médinoc

J'ignore s'il est seulement possible de faire le produit scalaire de deux vecteurs "liste"...

Sans aucun problème, du moins dans un espace préhilbertien (K-espace vectoriel muni, justement, d'un produit scalaire).
Cf. cette page si tu veux les formules du produit scalaire "général".

**Médinoc** · 05/10/2009, 13h17

C'est un peu technique pour moi, mais d'après ce que j'ai cru comprendre, ils doivent à ce moment-là avoir le même nombre de valeurs, non?

**Mac LAK** · 05/10/2009, 13h57

Envoyé par Médinoc

C'est un peu technique pour moi, mais d'après ce que j'ai cru comprendre, ils doivent à ce moment-là avoir le même nombre de valeurs, non?

Ils doivent être dans le même espace, donc ils sont forcément de même dimension (= "taille"), bien que l'on puisse considérer aussi que les valeurs manquantes sont des zéros par défaut (c'est crade, toutefois...).

**ben54120** · 05/10/2009, 14h05

D'accord, de toute manière je me suis décidé, mon tableau représentera désormais les coordonnées de mon vecteur, et la taille sera la dimension

Maintenant je suis bloqué sur un autre problème, certainement bien moins grave, mais quand on a jamais fait de C et de C++, c'est galère...

Je veux donc afficher mon vecteur sous la forme "taille(coordonnées)". Mes coordonnées sont donc un tableau pointant sur des entiers, lors de l'affichage, cela me donne bien entendu l'adresse mémoire...Voici mon opérateur de sortie :

Code :

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

1
2
3
4
5
6
7
8
 
  ostream& operator<<(ostream& o, vecteur& a) {
    char str[100];
    for(int i=0;i<a.taille;i++) {
      str[i]=("%d",(char)(a.tab[i]));
    }
    return o << a.taille << "(" << str << ")" << endl;
  }

**Médinoc** · 05/10/2009, 15h18

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
ostream& operator<<(ostream& o, vecteur const& a) {
	o << a.taille << "(";
 
	for(size_t i=0 ; i<a.taille ; i++) {
		if(i != 0) {
			o << ' ';
		}
		o << a.tab[i];
	}
	return o << ")" << endl;
}

**Médinoc** · 05/10/2009, 15h47

Note que si on part dans des considérations géométriques, les vecteurs ne suffisent peut-être pas à tout modéliser: À ce moment-là, je suis du genre à le coupler avec une autre classe, genre une classe point. On obtient ainsi une correspondance entre "coordonnées absolues" et "coordonnées relatives", comme dans d'autres couples:

En C et C++: pointeur (absolu) et entier (relatif)
En .Net: DateTime (absolu) et TimeSpan (relatif)
En géométrie: point (absolu) et vecteur (relatif)

On obtient ainsi des opérations de ce type:

point1 + point2 INTERDIT
point1 - point2 = vecteur21
point1 + vecteur12 = point2
vecteurAB + vecteurBC = vecteurAC
point1 * entier1 INTERDIT
vecteur1 * entier1 = vecteur2

**ben54120** · 05/10/2009, 15h57

Merci ça marche du tonnerre !

Il ne me reste plus que le produit scalaire à faire et l'opérateur d'entrée istream.

Pour le produit scalaire, la formule c'est ||v1||x||v2||xcos(µ), mais dans notre cas, comment calculer l'angle ?? ça va être galère ça...

Et puis pour le istream, je n'ai strictement aucune idée comment démarrer !

**Médinoc** · 05/10/2009, 16h02

Calculer le cosinus dans le plan, il me semble que ça n'était pas trop dûr. Dans l'espace, je ne sais pas trop comment faire, mais il y a forcément un moyen de ramener ça dans le plan (si on attache deux vecteurs au même point d'origine, ils sont forcément coplanaires) mais je n'ai pas non plus les formules mathématiques pour ça sous la main.

**ben54120** · 05/10/2009, 16h05

Et pour le istream, tu peux m'éclairer un petit peu ?

Le but était de pouvoir saisir directement la taille et les coordonnées du vecteur, mais je ne sais pas du tout comment faire !

La surcharge d'opérateurs

C++

Discussions similaires

Partager

Partager