Discussion :

[marcolo]

Bonjour,
j'ai un probleme bete, c'est que les compilateurs que j'ai (icc, g++) ne disent rien lorsqu'une valeur complexe est utilisee comme lvalue. Alors qu'il genere bien une erreur pour les doubles, il ne dit rien pour les complexes. Y-a t'il une option de compilation qui permettrait au compilateur de signaler cette erreur ?
Voici l'exemple qui compile (alors qu'il ne devrait pas) :

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
#include <complex>
#include <iostream>
#include <vector>
 
using namespace std;
 
template<class T>
class Vector
{
protected :
  vector<T> data_;
 
public :
 
  Vector(int n) : data_(n)
  {
  }
 
  T operator()(int i) const
  {
    return data_[i];
  }
 
};
 
 
int main()
{
  int n = 10;
  //Vector<double> x(n);                                                                                                                                                                        
  //x(0) = 1.3;                                                                                                                                                                                 
 
  Vector<complex<double> > x(n);
  x(0) = complex<double>(1.3, 4.5);
 
  return 0;
}

Si vous decommentez les lignes pour double (et commentez celles avec complex<double> ), vous verrez que ca genere bien l'erreur souhaitee a la compilation.

Je precise que je veux implementer un operateur () const qui renvoie une valeur et pas une reference, et je voudrais que le compilo signale les endroits ou ya x(i) = quelque chose.

[alexisdm]

Si tu ajoutes un const, tu auras bien ton erreur (mais elle ne sera pas aussi évidente à comprendre qu'avec un type de base):

Code :

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

const T operator()(int i) const

[N i h i l]

Voici l'exemple qui compile (alors qu'il ne devrait pas)

Il doit compiler, et il compile.

Mais ton problème n'a rien à voir avec std::complex<>. Teste :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 
struct S {} s;
 
int main { 
 
  Vector< S > x(10);
 
  x(0)= s;
}

Tu observes une différence entre un double et un std::complex< double > parce que l'un est un class type et pas l'autre. Quand tu écris

Code :

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

  x(0)= complex< double >(1.3, 4.5);

le compilateur lit

Code :

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

1
2
 
x(0).operator=(complexe< double >(1.3, 4.5))

ce qui est valide. À l'exécution c'est une no-op ; as-tu regardé la valeur de x(0) après l'affectation ?

Je precise que je veux implementer un operateur() const qui renvoie une valeur et pas une reference, et je voudrais que le compilo signale les endroits ou ya x(i) = quelque chose.

Ce n'est pas possible, sauf à suivre le conseil de alexisdm.

Pourquoi tiens-tu à ce que ton operator() const retourne une valeur ?

[marcolo]

Merci pour vos explications, j'ai bien compris le probleme. J'ai adopte la solution de alexisdm en rajoutant un const. C'est vrai que l'erreur obtenue est moins explicite, mais ce que je voulais avant tout c'etait la generation d'une erreur.

[3DArchi]

Salut,
La constance suffit à générer une erreur que le retour se fasse par référence ou par valeur:

Code :

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

  T const &operator()(int i) const

ou

Code :

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

  T const operator()(int i) const

[N i h i l]

La constance suffit à générer une erreur que le retour se fasse par référence ou par valeur:

Code :

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

  T const operator()(int i) const

Mais, dans ce cas, n'interdit-elle pas la RVO ?

[3DArchi]

Mais, dans ce cas, n'interdit-elle pas la RVO ?

Quel est le rapport avec la question initiale ?

[Matthieu Brucher]

Pourquoi tiens-tu à ce que ton operator() const retourne une valeur ?

En environnement multithreadé, c'est quasiment indispensable.

[3DArchi]

En environnement multithreadé, c'est quasiment indispensable.

Pourquoi ?

[Matthieu Brucher]

Si tu renvoies une référence et que tu travailles dessus, tu n'es pas certain qu'elle reste valide, sauf à garder un gros mutex. Et c'est pas très performant dans ce cas.

[3DArchi]

Mais si tu dois copier tout les éléments de ton vecteur, ça peut aussi être assez inefficace, non ?