Discussion :

[mamelouk]

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 :

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

1
2
3
4
5
6
7
class VideoParser {
public:
    VideoParser(std::string filename);
    ~VideoParser();
    void read();
 
};

pourquoi ceci compile:

Code :

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

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

tandis que ceci, non :

Code :

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

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

voici l'erreur :

Code :

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

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

[rikau2]

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.

[mamelouk]

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?

[rikau2]

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

[mamelouk]

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 ?

[koala01]

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 :

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

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 :

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

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

[mamelouk]

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

[koala01]

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 :

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

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 :

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

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)

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

[r0d]

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

Non. C'est

Code :

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

new std::string();

qui renvoie un std::string*

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

Code :

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

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 :

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

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 :

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

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

fonctionne

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

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.

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

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 :

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

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

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

[r0d]

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.

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 :

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

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

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

Code :

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

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.

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.

[mamelouk]

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

[koala01]

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 :

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

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

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

[Sylvain Togni]

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

Code :

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

A a(B(c));

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

Code :

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

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.

[mamelouk]

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

Code :

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

A a(B(c));

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

Code :

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

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 :

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

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

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

[Sylvain Togni]

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

[mamelouk]

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

[rikau2]

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

[Mat007]

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 :

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

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

MAT.

[mamelouk]

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

Code :

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

        int fonction(int a); // ok

mais pas le corps de la fonction

Code :

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

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

Code :

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

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

de plus, ceci :

Code :

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

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

est bien un appel de fonction

ok j'était aveugle mais maintenant je vois.