La surcharge d'opérateurs

Version imprimable

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:

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

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:

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:

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

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:

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:

1 2 T& operator++(); //prefix T operator++(int); //postfix
Et voici le squellette de ces opérateur :
Code:

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 [] ;)

04/10/2009, 11h30
ben54120

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 ?
04/10/2009, 11h52
Goten
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:

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).

ok

Le rendu de l'erreur est :

Code:

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

04/10/2009, 11h59
Goten

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

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

Alors j'ai trois fichiers :
Voici le fichier vecteur.h :

Code:

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:

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:

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:

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

05/10/2009, 11h01
Médinoc
Citation:

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.
1. L'opérateur d'affectation ne retourne pas un nouvel objet, il modifie l'objet courant et retourne une référence vers lui.
2. 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.
3. Voir plus haut.
05/10/2009, 11h22
ben54120

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
05/10/2009, 11h43
Médinoc

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"...
05/10/2009, 12h44
Mac LAK

Citation:

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".
05/10/2009, 13h17
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?
05/10/2009, 13h57
Mac LAK

Citation:

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...).

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 :D

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:

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

Code:

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

05/10/2009, 15h47
Médinoc
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
05/10/2009, 15h57
ben54120

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 !
05/10/2009, 16h02
Médinoc

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.
05/10/2009, 16h05
ben54120

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 !

En entrée, sans doute un truc de ce genre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
istream& operator>>(istream& i, vecteur & a) {
	size_t taille;
	i >> taille;
	/*Note: Il faut que la classe vecteur ait un opérateur d'affectation correct.
	  Mais on peut aussi faire plus simple si on a une fonction membre setsize() ou un truc du genre */
	a = vecteur(taille); /*en supposant un constructeur qui prend la taille en paramètre pour allouer */
 
	i.ignore(numeric_limits<streamsize>::max, '(');
 
	for(size_t i=0 ; i<a.taille ; i++) {
		i >> a.tab[i];
	}
	i.ignore(numeric_limits<streamsize>::max, ')');
	return i;
}

Bien sûr, il faudrait ajouter la gestion d'erreurs par-dessus...

ok, mais il y a une bibliothèque quelconque à inclure ? Parce que là ça plante :

Code:

1
2
3
4
5
6
7
8
9
 
Vecteur.cc: In function ‘std::istream& operator>>(std::istream&, vecteur&)’:
Vecteur.cc:158: erreur: ‘numeric_limits’ was not declared in this scope
Vecteur.cc:158: erreur: expected primary-expression before ‘>’ token
Vecteur.cc:162: attention : name lookup of ‘i’ changed
Vecteur.cc:154: attention :   matches this ‘i’ under ISO standard rules
Vecteur.cc:159: attention :   matches this ‘i’ under old rules
Vecteur.cc:162: erreur: expected primary-expression before ‘>’ token
make: *** [Vecteur.o] Erreur 1

Et puis comment on s'en sert ? Il va attendre qu'on saisisse ou bien il faut mettre ./tp 5 1 2 3...

05/10/2009, 16h55
Goten

pour numeric_limits :
#include <limits>

C'est pire ^^

Code:

1
2
3
4
5
6
7
8
9
10
 
Vecteur.cc: In function ‘std::istream& operator>>(std::istream&, vecteur&)’:
Vecteur.cc:158: erreur: invalid conversion from ‘int (*)()throw ()’ to ‘std::streamsize’
Vecteur.cc:158: erreur:   initializing argument 1 of ‘std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::ignore(std::streamsize, typename _Traits::int_type) [with _CharT = char, _Traits = std::char_traits<char>]’
Vecteur.cc:162: attention : name lookup of ‘i’ changed
Vecteur.cc:154: attention :   matches this ‘i’ under ISO standard rules
Vecteur.cc:159: attention :   matches this ‘i’ under old rules
Vecteur.cc:162: erreur: invalid conversion from ‘int (*)()throw ()’ to ‘std::streamsize’
Vecteur.cc:162: erreur:   initializing argument 1 of ‘std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::ignore(std::streamsize, typename _Traits::int_type) [with _CharT = char, _Traits = std::char_traits<char>]’
make: *** [Vecteur.o] Erreur 1

05/10/2009, 17h35
Mac LAK

Citation:

Envoyé par ben54120

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...

Tu dois utiliser les formules générales du produit scalaire, cf. le lien que j'ai donné page précédente.
05/10/2009, 17h42
Goten

J'avais pas vu, t'as copié collé direct? medinoc a utilisé deux fois i... forcément ça péte.
05/10/2009, 17h49
Médinoc

Oups :oops:

Maintenant ça donne ceci ^^

Code:

1
2
3
4
5
6
7
8
9
 
g++ -I/usr/openwin/include -c -Wno-deprecated Client.cc
g++ -I/usr/openwin/include -c -Wno-deprecated Vecteur.cc
Vecteur.cc: In function ‘std::istream& operator>>(std::istream&, vecteur&)’:
Vecteur.cc:158: erreur: invalid conversion from ‘int (*)()throw ()’ to ‘std::streamsize’
Vecteur.cc:158: erreur:   initializing argument 1 of ‘std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::ignore(std::streamsize, typename _Traits::int_type) [with _CharT = char, _Traits = std::char_traits<char>]’
Vecteur.cc:162: erreur: invalid conversion from ‘int (*)()throw ()’ to ‘std::streamsize’
Vecteur.cc:162: erreur:   initializing argument 1 of ‘std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::ignore(std::streamsize, typename _Traits::int_type) [with _CharT = char, _Traits = std::char_traits<char>]’
make: *** [Vecteur.o] Erreur 1

05/10/2009, 20h26
Médinoc

Essaie peut-être avec numeric_limits<int> au lieu de numeric_limits<streamsize>, à part ça je ne vois pas trop.

Non il me dit toujours pareil :(

Code:

1
2
3
4
5
6
7
8
9
 
g++ -I/usr/openwin/include -c -Wno-deprecated Client.cc
g++ -I/usr/openwin/include -c -Wno-deprecated Vecteur.cc
Vecteur.cc: In function ‘std::istream& operator>>(std::istream&, vecteur&)’:
Vecteur.cc:158: erreur: invalid conversion from ‘int (*)()throw ()’ to ‘std::streamsize’
Vecteur.cc:158: erreur:   initializing argument 1 of ‘std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::ignore(std::streamsize, typename _Traits::int_type) [with _CharT = char, _Traits = std::char_traits<char>]’
Vecteur.cc:162: erreur: invalid conversion from ‘int (*)()throw ()’ to ‘std::streamsize’
Vecteur.cc:162: erreur:   initializing argument 1 of ‘std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::ignore(std::streamsize, typename _Traits::int_type) [with _CharT = char, _Traits = std::char_traits<char>]’
make: *** [Vecteur.o] Erreur 1

Citation:
Envoyé par ben54120
Code:

1 2 Vecteur.cc:162: erreur: invalid conversion from ‘int (*)()throw ()’ to ‘std::streamsize’
Faut toujours lire les erreurs : le compilo te dit qu'il cherche à convertir un int(*)()throw() en un std::streamsize ? Mais qu'est ce qu'un int(*)()throw() ? Ca ressemble à un pointeur de fonction. Donc il croit que std::numeric_limits<streamsize>::max est une fonction ... Et si c'était le cas. Regardons la doc :
Code:

1 2 3 4 5 template <class T> class numeric_limits { public: static const bool is_specialized = false; static T min() throw(); static T max() throw();
C'est donc bien ça.
Modifions donc les appels comme suit :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <istream> #include <limits> istream& operator>>(istream& is_, vecteur & a) { size_t taille; is_ >> taille; /*Note: Il faut que la classe vecteur ait un opérateur d'affectation correct. Mais on peut aussi faire plus simple si on a une fonction membre setsize() ou un truc du genre */ a = vecteur(taille); /*en supposant un constructeur qui prend la taille en paramètre pour allouer */ is_.ignore(numeric_limits<streamsize>::max(), '('); for(size_t i=0 ; i<a.taille ; i++) { is_ >> a.tab[i]; } is_.ignore(numeric_limits<streamsize>::max(), ')'); return is_; }
Magique ! Ca compile.
Morale de l'histoire : le compilateur est mon meilleur ami surtout si je fais l'effort de regarder ce qu'il me dit ;)

06/10/2009, 11h33
ben54120

Regarder ce qu'il dit c'est une chose, la comprendre c'en est une autre !
06/10/2009, 19h41
koala01

Salut,

Citation:

Envoyé par ben54120

Regarder ce qu'il dit c'est une chose, la comprendre c'en est une autre !

C'est vrai que la connaissance (même limitée) de l'anglais aide un peu :P

De même, il faut parfois connaitre quelques particularités du langages, comme, dans le cas présent, les pointeurs de fonctions qui prennent souvent la forme de TypeDeRetour(*nomD'unPointeur)(ListeD'arguments), voire TypeDeRetour(*nomD'unPointeur)(ListeD'arguments)throw()..

Mais, d'un autre coté, un peu de logique aide aussi souvent:

Ainsi, lorsque tu vois une erreur qui prend la forme de

Citation:

invalid conversion from 'blabla' to 'truc'

il ne faut pas *forcément* sortir de math sup pour savoir que le compilateur se plaint de ne pas savoir convertir un "blabla" en un "truc" :P

En allant, simplement, voir à la ligne à laquelle se produit la première erreur (ben oui, le compilateur nous sort parfois une liste impressionnante d'erreurs, qui découlent en définitive souvent de la première ;)), il n'est malgré tout pas *si* difficile que cela de comprendre que le code que l'on a écrit représente le "blabla" alors que le compilateur attend... un "truc" :P

A partir de là, entre le net, la documentation et les fichiers d'en-tête (qui seront, quoi qu'il arrive, toujours accessibles), il ne reste plus qu'à savoir ce que l'on recherche :D

Je ne dis pas que certaines erreurs ne peuvent pas être particulièrement obscures (surtout lorsque l'on se met à manipuler des classes template :roll:), mais ici, ce n'est malgré tout pas vraiment le cas ;)