[syntaxe] erreur de compilation pas comprise

Salut,

Avant tout, j'ai résolu mon problème je ne suis pas bloqué, mais je ne comprends pas l'erreur, alors je voulais vous demander.


voici ma question du jour. sachant que j'ai une classe:

Code:

---

1 2 3 4 5 6 7

class VideoParser { public: VideoParser(std::string filename); ~VideoParser(); void read();   };

---

pourquoi ceci compile:

Code:

---

1 2 3

string filename(argv[1]); VideoParser videoParser(filename); videoParser.read();

---

tandis que ceci, non :

Code:

---

1 2 3

VideoParser videoParser( string(argv[1]) ); videoParser.read();

---

voici l'erreur :

Code:

---

1 2	In function «int main(int, char**)": erreur: request for member «read" in «videoParser", which is of non-class type «VideoParser () (std::string*)"

---

argv[1] est un char* et donc je pense que si tu le passes directement ca marche mieux...

un cast c'est plutot comme ca: ((std::string)argv[1])
si tu fais std::string mastring;
mastring = "abcd..."; la camarche
mastring = std::string("abcd..."); ne fonctionnera pas;

par contre std::string *mastring = new std::string("asdf"); fonctionnera.

je comprends pas ce que tu veut dire.

ma fonction je lui passe un string qui est construit à partir d'une chaine de caractère (char*), et pourtant ca marche pas: pourquoi?

Désol´, j'avais validé avant de finir la reponse....

Quand tu fais un string(machaine); ca te retourne un std::string *
Le constructeur de ta classe est basé sur un std::string.

Le problème vient de la

std::string() renvoie un std::string* ?

je savais pas, je pensais que par convention le constructeur renvoyait un objet et qu'on avait pas à se soucier de sa destruction (contrairement à l'aide du mot clé new).

Ce n'est pas le cas pour std::string :? ?

Salut,

La bonne habitude à prendre est de passer les paramètres au constructeurs sous forme de référence constante, surtout quand il s'agit de types "utilisateurs" (structures ou classes... fussent-elles fournies par une bibliothèque ;))

L'avantage, c'est qu'il y a alors moyen de faire passer une chaîne "C style" comme paramètre:

Code:

---

1 2 3 4 5 6 7 8

class VideoParser { public: VideoParser(const std::string& filename); ~VideoParser(); void read();   };

---

te permet d'utiliser le constructeur sous une forme proche de

Code:

---

1 2 3 4 5 6 7

int main(int argc, char* argv) { /* normalement il y a intérêt à vérifier les arguments passés ;) */ VideoParser parser(argv[1]); parser.read(); /* ... */ }

---

Autrement, la première chose que tu devra faire est... de convertir ta chaine "C style" en ... std::string :P

c'est très gentil (car c'est un bon conseil), mais ca répond pas à ma question :lol:

Ma première réponse est, quand même beaucoup plus proche de celle que tu attends que cela ne semble de prime abord:

L'avantage de passer une référence (constante) comme paramètre est que tu ne nécessite pas de recopie, et que cela permet de travailler plus correctement:

Dans le code

Code:

---

1 2 3

string filename(argv[1]); VideoParser videoParser(filename); videoParser.read();

---

tu travailles en deux temps:

Tu construit une variable de type std::string et nommée filename sur base du char* récupéré en argv[1], ce qui est parfaitement autorisé parce qu'il y a un constructeur std::string::string(const char*) dans la classe string.

Puis, tu appel le constructeur de VideoParser en lui fournissant une copie (appel à std::string(const std::string&)) d'une chaîne correcte.

Dans le deuxième exemple:

Code:

---

1 2 3 4

VideoParser videoParser(string (argv[1])); videoParser.read();

---

la partie "string (argv[1])" crée une variable temporaire non nommée de type std::string... Et c'est une copie de cette variable temporaire qui est sensée être fournie à VideoParser::VideoParser(std::string) :P

Le problème, c'est que la std::string ne dispose pas d'un constructeur par copie prenant une std::string non constante (le constructeur par copie de std::string est std::string::string(const std::string&))... et donc, ne sait pas fournir la std::string nommé "filename" au constructeur de VideoParser

Citation:

---

Envoyé par mamelouk

std::string() renvoie un std::string* ?

---

Non. C'est

Code:

---

new std::string();

---

qui renvoie un std::string*

En revanche, tu poses une bonne question. Prenons un exemple qui utilise la classe suivante:

Code:

---

1 2 3 4 5 6

class Dum { public: Dum(const std::string &str):str_(str){} std::string str_; };

---

Pourquoi est-ce que ceci:

Code:

---

1 2 3 4 5

int main(int argc, char** argv) { Dum dum( std::string(argv[1]) ); //code }

---

ne fonctionne pas, alors que ceci:

Code:

---

1 2 3 4 5 6

int main(int argc, char** argv) { std::string str = std::string(argv[1]); Dum dum( str ); // code }

---

fonctionne :question:

La compilation du premier main (sous visual8) me donne quelque chose d'étrange. J'obtiens ce warning:

Citation:

---

warning C4930: 'Dum dum(std::string [])': prototyped function not called (was a variable definition intended?)

---

et ça compile, mais l'objet dum n'est pas créé à l'exécution.

eh bien c'est bizarre si ca compile, peut etre que le compilateur a optimisé ton code ; la variable n'est pas utilisé donc viré des sources;

par contre, la réponse à ma question semble etre ce que disait koala:

Citation:

---

Envoyé par koala01

Le problème, c'est que la std::string ne dispose pas d'un constructeur par copie prenant une std::string non constante (le constructeur par copie de std::string est std::string::string(const std::string&))... et donc, ne sait pas fournir la std::string nommé "filename" au constructeur de VideoParser

---

mais alors pour quoi ce code fonctionne:

Code:

---

1 2 3

string filename(argv[1]); VideoParser videoParser(filename); videoParser.read();

---

alors que filename n'est pas déclaré const ?

Citation:

---

Envoyé par mamelouk

eh bien c'est bizarre si ca compile, peut etre que le compilateur a optimisé ton code ; la variable n'est pas utilisé donc viré des sources;

---

J'ai compilé en mode debug. Il ne vire rien en mode debug.

Citation:

---

par contre, la réponse à ma question semble etre ce que disait koala:

---

Je ne crois pas. Ou alors j'ai mal compris. Je ne comprends pas pourquoi le compilo arrive à créer une string comme ceci:

Code:

---

std::string str = std::string(argv[1]);

---

mais qu'il n'arrive pas à en créer une dans ce cas là:

Code:

---

Dum dum( std::string(argv[1]) );

---

Je pense qu'il y a une histoire de variable non nommée, mais je ne vois pas trop le rapport.

Citation:

---

mais alors pour quoi ce code fonctionne alors que filename n'est pas déclaré const ?

---

Car le compilo fait un const_cast automatiquement et de façon cachée dans ce cas.

oui en fait, pareil que toi, j'ai édité mon message après

Citation:

---

Envoyé par mamelouk

eh bien c'est bizarre si ca compile, peut etre que le compilateur a optimisé ton code ; la variable n'est pas utilisé donc viré des sources;

par contre, la réponse à ma question semble etre ce que disait koala:



mais alors pour quoi ce code fonctionne:

Code:

---

1 2 3

string filename(argv[1]); VideoParser videoParser(filename); videoParser.read();

---

alors que filename n'est pas déclaré const ?

---

Parce que ce n'est pas une variable temporaire...

Le problème n'est pas tant le fait qu'une std::string fournie en paramètre soit const ou non avant qu'on ne la passe en paramètre, le problème est que ce ne peut pas être une variable temporaire :P

Effectivement, le compilateur sait faire un const_cast de manière silencieuse... à condition qu'il dispose d'un objet ... non temporaire sur lequel l'appliquer

L'erreur viens du fait qu'un code du type

Code:

---

A a(B(c));

---

n'est pas l'instanciation d'une variable mais la définition d'une fonction. C'est équivalent à

Code:

---

A a(B c);

---

c'est à dire que ça défini une fonction a qui retourne un objet de type A et qui prend un objet de type B nommé c.

Citation:

---

Envoyé par Sylvain Togni

L'erreur viens du fait qu'un code du type

Code:

---

A a(B(c));

---

n'est pas l'instanciation d'une variable mais la définition d'une fonction. C'est équivalent à

Code:

---

A a(B c);

---

c'est à dire que ça défini une fonction a qui retourne un objet de type A et qui prend un objet de type B nommé c.

---

ah bon ? j'ai bien fait de poser la question j'en apprends des tonnes.. ou alors tout le monde me dis n'importe quoi.
je savais pas que l'on pouvait déclarer une fonction comme cela:

Code:

---

Dum dum( string(argv[1]) );

---

le nom du paramètre serait donc argv[1] de type string ??! :roll:

Presque, le paramètre est argv, de type string[1].

on peut déclarer une fonction dans le corps du main() ?

Il n'y a pas de declaration de fonction mais un appel a une fonction

Salut,

Oui c'est une déclaration de fonction.
Et oui on peut déclarer une fonction dans le corps d'une autre fonction, par contre je ne sais pas si ça fait vraiment partie du standard C++ ou si c'est pour la compatibilité avec le C.

Pour forcer le compilateur à voir ça comme un appel de fonction on peut faire :

Code:

---

Dum dum( (std::string( argv[1] )) );

---

MAT.

apparement dans gcc 4, on peut déclarer un prototype de fonction dans une autre fonction

Code:

---

int fonction(int a); // ok

---

mais pas le corps de la fonction

Code:

---

1 2 3

int fonction(int a){ return ++a; } // pas ok

---

Code:

---

erreur: a function-definition is not allowed here before «{" token

---

de plus, ceci :

Code:

---

1 2	int a=1; int fonction((int(a)); // ok

---

est bien un appel de fonction

ok j'était aveugle mais maintenant je vois.