Discussion :

[deubelte]

Autre question sur l'appel de fonction.
Il semble qu'il y a des fonctions qui prennent des arguments, mais qui ne sont pas écrits, explicitement dans la liste d'arguments.
Par exemple, la fonction f2 définie ici:

http://msdn.microsoft.com/en-us/libr...48(VS.80).aspx

je la redonne ici:

Code :

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

 void f2(C2)  {}

C2 est une classe, mais il n'y a pas d'arguments. Que fait une telle fonction?
Si on veut faire qqch de l'argument de type C2, que fait-on?
merci

[koala01]

Dans le cas que tu présente, il est plus que possible que la fonction doive respecter une certaine signature, mais que, exceptionnellement (sans doute parce que c'est une fonction virtuelle), l'argument ne sera pas utilisé.

Si nous nommions l'argument, le compilateur se plaindrait d'avoir une variable (non de l'argument) définie mais jamais utilisée.

Si on souhaite pouvoir accéder à l'argument, il faudra lui donner un nom

[deubelte]

D'ailleurs, dans le code de la page MSDN, il y a une conversion, que je reproduis ici:

Code :

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

1
2
3
4
5
6
void g(int i)
{
    f2(i);   // C2558
    // try the following line instead
    // f2(C2(i));
}

Ne faudrait-il pas, pour être en conformité avec le C++, écrire:

Code :

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

 f2(static_cast<C2>(i));

plutôt que

Code :

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

 f2(C2(i));

Enfin, quand on déclare un constructeur "explicit", et que l'on fait passer un argument par valeur, il y a appel du constructeur par copie.
Mais je ne comprends pas pourquoi cela provoque une erreur.

Car si on déclare un objet c (en l'occurence de classe C dans le cas présent)
et que l'on fait par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
C  f(C c){   
    c.i = 2;
    return c;   // first call to copy constructor
}
int main(){
 
    C c, d;
d = f(c);    //   c is copied 
}

il y aura deux erreurs, l'une pour f(c) l'autre pour return c.
mais où sera la conversion implicite?
Merci

[3DArchi]

Cela correspond au 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <iostream>
class C
{
public:
    int i;
    explicit C(const C&)   // an explicit copy constructor
    {
        std::cout<<"\nin the copy constructor";
    }
    explicit C(int i )   // an explicit constructor
    {
        std::cout<<"\nin the constructor";
    }
 
    C()
    {
        i = 0;
    }
};
 
class C2
{
public:
    int i;
    explicit C2(int i )   // an explicit constructor
    {
    }
};
 
C f(C c)
{   // C2558
    c.i = 2;
    return c;   // first call to copy constructor
}
 
void f2(C2)
{
}
 
void g(int i)
{
    f2(i);   // C2558
    // try the following line instead
    // f2(C2(i));
}
 
int main()
{
    C c, d;
    d = f(c);   // c is copied
 
    return 0;
}

L'idée est de mettre en évidence partout où un constructeur était appelé. En le mettant explicit, cela force à appeler explicitement le constructeur et donc prendre conscience où ces appels avaient lieu.

[deubelte]

oK, je sais bien. Mais en quoi ce code pose t il un pb au compilateur:
quand je rentre ce code dans vC2010, j'ai pour erreur;

class "C" has no suitable copy constructor

De plus, ai-je raisons quant à ma remarque sur le static_cast?

[koala01]

Il faudrait voir de quoi est composé C, comment tu essaye de construire un objet de type C, et comment tu essaie de construire tes objets dont le type dérive de C.

si tu essaye d'invoquer un constructeur de C prenant un paramètre alors qu'il n'existe aucune constructeur acceptant le type de paramètre en question, ou, au contraire, si tu essaye de construire C en ne lui fournissant aucun argument alors qu'il en attend un, fatalement, le compilateur ne pourra jamais déterminer quel constructeur il doit invoquer.

C'est, en gros, ce que te dis le message d'erreur.

Ainsi, il est plus que probable que tu aies une classe C proche de

Code :

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

1
2
3
4
5
class C
{
    public:
        explicite C(int i);
};

et que le constructeur de la classe C2 qui dérive de C n'appelle pas explicitement le constructeur... prenant un entier de C.

Ou, c'est l'inverse qui se passe: C dispose d'un constructeur "par défaut", mais d'aucun constructeur demandant un entier, et tu essaye d'invoquer un constructeur pour C en lui donnant un entier.

Et, pour répondre à ta dernière question, tu as tord au niveau du static_cast.

Il faut comprendre que les static_/dynamic_/reinterpret_ cast provoquent ce que l'on appelle le transtypage.

Cela revient à faire passer un(e référence ou un pointeur sur un) objet de type X pour un(e référence ou un pointeur sur un) objet Y, en appliquant des "normes de sécurité" variable au moment où on prend la décision.

Cela implique que tu... dois avoir, effectivement, un objet à transtyper

Le constructeur, quant à lui, permet de créer un objet "tout beau, tout propre" du type indiqué et d'en définir les membres sur base des informations que l'on transmet (et que l'on a sans doute récupérées par ailleurs).

Par contre, une fois qu'un objet a été créé (que son constructeur a été appelé), on peut envisager de le transtyper en un autre, pour autant que l'on respecte certaines règles

Il faut aussi noter que le transtypage n'a rien à voir avec une quelconque conversion...

La création ou la conversion de type créent réellement une nouvelle variable, alors que le transtypage revient (en y allant, il est vrai, un peu fort) à mentir au compilateur sur le type de l'objet que l'on utilise

[mailaka]

Cela correspond au code :

Code :

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

1
2
3
4
5
6
7
8
9
 
C f(C c)
{   // C2558
    c.i = 2;
    return c;   // first call to copy constructor
}
....
 
d = f(c);   // c is copied

Attendez. Le 1er commentaire a l'air de dire que c'est a l'instruction return c que le constructeur de copie est appele. Si je ne m'abuse, c'est plutot au passage de parametre (et uniquement la) lors de l'appel suivant non ?

[3DArchi]

Salut,
La réponse est : les 2 !
Une construction par copie a lieu lorsque le paramètre est transmis à la fonction. Mais le résultat aussi est retourné par valeur et provoque donc un appel au constructeur par copie.

[bruno_pages]

c'est pour cela qu'il faut tant que faire ce peut ne pas passer les instances par valeur mais par référence constante, sinon le code passe son temps a recopier les éléments

de même un getter sur un attribut retournera une référence constante et non la valeur recopiée

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class A {...};
 
class B {
public:
  void recopie_param(A a) {...}
  void pas_recopie_param(const A & a) { ... }
 
  A recopie_valeur() const { return a; }
  const A & pas_recopie_valeur() const { return a; }
 
private:
  A a;
};

dans le cas ou la 'valeur' calculée par une opération est une collection ou autre structure complexe, il est préférable de ne pas rendre la valeur mais d'utiliser un paramètre de sortie, exemple :

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
 
#include <list>
using namespace std;
 
class A {
public:
   list<A> duplicate1(unsigned n) {
      list<A> l;
 
      while (n--) l.push_back(this);
      return l;
   }
 
   void duplicate2(list<A> & l, unsigned n) {
     l.clear(); // to be sure
     while (n--) l.push_back(this);
   }
};

l'utilisation de duplicate1 provoque une recopie inutile de la liste temporaire et des A qu'elle contient

[Alp]

c'est pour cela qu'il faut tant que faire ce peut ne pas passer les instances par valeur mais par référence constante, sinon le code passe son temps a recopier les éléments

Je ne serais pas aussi catégorique que toi.

[3DArchi]

Salut,
Le code proposé par deublete est là pour illustrer les constructeurs explicites et y compris celui de copie.