Discussion :

[coberle]

Bonjour,

Je rencontre le problème suivant et je n'arrive pas à savoir d'où ça vient. Ci dessous un extrait du 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
 
class P
{
   public:
      P(double aX, double aY):coord({aX,aY}) {};
 
      vector<double> getCoord() const;
      void init(const P &Pt);
 
   private:
     vector<double> coord;
};
 
 
vector<double> P::getCoord() const
{
    return coord;
}
 
 
 
void P::init(const P &Pt)
{
    vector<double> test({1.0,2.0}); //OK
    vector<double> test2(Pt.getCoord()); //OK
 
    coord.swap(test); //OK
    coord.swap(test2); //OK
 
    // coord(test); //error: no match for call to '(std::vector<double>) (std::vector<double>&)'|
    // coord(Pt.getCoord()); //error: no match for call to '(std::vector<double>) (std::vector<double>)': 
    // coord.swap(Pt.getCoord()); //error: no matching function for call to std::vector<double>::swap(std::vector<double>)'
}

Pourtant, on doit pouvoir initialiser un vecteur à partir d'un autre (cf http://www.cplusplus.com/reference/v...vector/vector/)

Christian

[Kaamui]

Code :

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

1
2
3
4
5
 
// coord(test); //error: no match for call to '(std::vector<double>) (std::vector<double>&)'|
    // coord(Pt.getCoord()); //error: no match for call to '(std::vector<double>) (std::vector<double>)': 
    // coord.swap(Pt.getCoord()); //error: no matching function for call to std::vector<double>::swap(std::vector<double>)'
}

coord n'est pas un type mais une instance. Pour la dernière erreur modifie le type de retour de getCoord avec une référence sur ton type de retour plutôt qu'une copie

[coberle]

Merci Kaamui pour ta réponse ... mais je ne saisi pas ce que tu veux dire par "coord n'est pas un type mais une instance". Peux-tu être plus explicite ?

[Trademark]

Cette syntaxe là : coord(test) sur un objet (ici coord de type std::vector<double>) fait appel à l'opérateur() de cet objet, or il n'est pas définit pour le type vector. Si tu veux réinitialiser ton objet, tu peux faire ça :

Code :

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

1
2
 
coord = std::vector<double>(Pt.getCoord());

Ensuite ton swap marcherait si tu renvoyais une référence de ton membre, mais de toute manière swap n'est pas l'opération qui t'intéresse vu que ça va aussi modifier l'argument passé à init. Par contre il vaut mieux que tu renvois une ref constante là :

Code :

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

1
2
 
const vector<double>& getCoord() const;

De manière plus général je pense que tu te plantes en créant une méthode init, utilise le constructeur ou remplace la valeur à plus haut niveau (la classe std::vector, comme tu as pu le constater ne propose pas de mécanismes "init" et pourtant on s'en sort bien sans). Ce qui donnerait à l'utilisation :

Code :

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

1
2
3
4
5
6
 
P pt(1, 2);
// Au lieu de 
pt.init(P(3, 4));
// Faire 
pt = P(3, 4);

[Kaamui]

Merci Kaamui pour ta réponse ... mais je ne saisi pas ce que tu veux dire par "coord n'est pas un type mais une instance". Peux-tu être plus explicite ?

Je voulais dire que ton écriture n'est pas valable pour ce que tu essayais de faire. Tu as défini une variable nommée coord de Type (class) A. Tu essaies ensuite d'appeler (j'ai l'impression) un constructeur par copie.

Code :

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

1
2
3
4
5
6
 
//la bonne syntaxe
Type Instance = Type(InstanceACopier) // Ici, Type() avec en paramètre une instance de type Type, est un constructeur par copie
 
//ta syntaxe
Instance(InstanceACopier) //Ici, tu n’appelles pas un constructeur par copie, mais l'opérateur () de la classe Type avec en paramètre (une référence vers) une instance de classe Type

Suis les conseils de Trademark

[coberle]

Merci Kaamui et Trademark pour votre répons et conseils. Got it (j'espère) !

[JolyLoic]

Je pense que le mieux est quand même d’initialiser tes données dans la liste d'initialisation du constructeur (pas de fonction init, c'est un mauvais signe qu'il y en ait une !!)

http://cpp.developpez.com/faq/cpp/?p...-l-affectation

[TropMDR]

Je voulais dire que ton écriture n'est pas valable pour ce que tu essayais de faire. Tu as défini une variable nommée coord de Type (class) A. Tu essaies ensuite d'appeler (j'ai l'impression) un constructeur par copie.

Le probleme est qu'il utilise la syntaxe d'initialisation

Code :

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

 vector<double> vect2(vect1);

pour l'affectation.

Code :

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

1
2
vector<double> vect2;
vect2(vect1); // INCORRECT! C'est un appel de "fonction", ca ne marche pas sur les vecteurs.

La syntaxe avec parenthese n'est valable qu'a l'initialisation d'une variable. Et oui, dans un constructeur, la syntaxe avec parenthese est loin du type de la variable, mais c'est quand meme une initialisation:

Code :

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

1
2
3
4
5
6
class Foo {
 public:
   Foo(const vector<double>& vect) : content_(vect) {}
 private:
   vector<double> content_;
}

[Kaamui]

ça ne marche pas justement parce que la classe vector n'implémente pas l'opérateur () : std::vector

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
 
#include <iostream>
#include <vector>
 
using namespace std;
 
class Foo
{
    public:
 
        vector<double> operator()(vector<double>& src)
        {
            return src;
        }
};
 
int main()
{
    vector<double> vect1 = {1, 2, 3};
    Foo vect2;
    vect2(vect1);
    return 0;
}

La "syntaxe avec parenthèse" est un constructeur par copie, ce qui explique qu'elle ne soit utilisable qu'à l'instanciation. Mais comme montré avec le code ci dessus, son code aurait très bien pu être valable par le biais d'une autre "syntaxe avec parenthèse". Le code ci-dessus compile.

[ternel]

La construction par copie est uniquement accessible dans une déclaration type variable(autre_variable);, ou un pasage d'argument sans référence.
Sinon (variable(autre_variable);), c'est l'appel à operator().

C'est très différent.

[Kaamui]

C'est exactement ce que j'ai dit.

[ternel]

Je ne l'avais pas compris.
Heureux d'être d'accord, en ce cas.