Michaël Monerau wrote:
// On prend un std::string avec les espaces en input std::string
sInput;
// voir pour cin.getline, je ne me souviens plus exactement // les
arguments...
plutot getline (istream&, string&, char), cin.getline utilisant un
char*.
std::string::iterator itFound; while ((itFound >> sInput.find_first_of (' ')) != sInput.npos) // un espace est
trouvé, on le supprime sInput.erase (itFound);
std::vector<bool> Result; std::transform (sInput.begin(),
sInput.end(), std::back_inserter<vector<bool>(Result),
BoolExtractor ());
Quitte a utiliser getline, pourquoi ne pas utiliser le manipulateur
ws pour virer les espace.
Personnellement je suis du partisant du "laisser faire le compilateur
s'il sait le faire, en général il est plus doué que moi".
Michaël Monerau wrote:
// On prend un std::string avec les espaces en input std::string
sInput;
// voir pour cin.getline, je ne me souviens plus exactement // les
arguments...
plutot getline (istream&, string&, char), cin.getline utilisant un
char*.
std::string::iterator itFound; while ((itFound >> sInput.find_first_of (' ')) != sInput.npos) // un espace est
trouvé, on le supprime sInput.erase (itFound);
std::vector<bool> Result; std::transform (sInput.begin(),
sInput.end(), std::back_inserter<vector<bool>(Result),
BoolExtractor ());
Quitte a utiliser getline, pourquoi ne pas utiliser le manipulateur
ws pour virer les espace.
Personnellement je suis du partisant du "laisser faire le compilateur
s'il sait le faire, en général il est plus doué que moi".
Michaël Monerau wrote:
// On prend un std::string avec les espaces en input std::string
sInput;
// voir pour cin.getline, je ne me souviens plus exactement // les
arguments...
plutot getline (istream&, string&, char), cin.getline utilisant un
char*.
std::string::iterator itFound; while ((itFound >> sInput.find_first_of (' ')) != sInput.npos) // un espace est
trouvé, on le supprime sInput.erase (itFound);
std::vector<bool> Result; std::transform (sInput.begin(),
sInput.end(), std::back_inserter<vector<bool>(Result),
BoolExtractor ());
Quitte a utiliser getline, pourquoi ne pas utiliser le manipulateur
ws pour virer les espace.
Personnellement je suis du partisant du "laisser faire le compilateur
s'il sait le faire, en général il est plus doué que moi".
Pourquoi faire une telle chose ? L'intérêt de std::string (en
particulier) est justement de ne pas s'occuper de la taille du string et
de faire les opérations dessus, comme ça nous plaît. Ensuite, c'est lui
qui s'occupe de redimensionner tout ça en dynamique, lorsqu'il y en a
besoin...
Pourquoi faire une telle chose ? L'intérêt de std::string (en
particulier) est justement de ne pas s'occuper de la taille du string et
de faire les opérations dessus, comme ça nous plaît. Ensuite, c'est lui
qui s'occupe de redimensionner tout ça en dynamique, lorsqu'il y en a
besoin...
Pourquoi faire une telle chose ? L'intérêt de std::string (en
particulier) est justement de ne pas s'occuper de la taille du string et
de faire les opérations dessus, comme ça nous plaît. Ensuite, c'est lui
qui s'occupe de redimensionner tout ça en dynamique, lorsqu'il y en a
besoin...
Pourquoi faire une telle chose ? L'intérêt de std::string (en
particulier) est justement de ne pas s'occuper de la taille du string et
de faire les opérations dessus, comme ça nous plaît. Ensuite, c'est lui
qui s'occupe de redimensionner tout ça en dynamique, lorsqu'il y en a
besoin...
C'est peut-être intéressant de temps en temps de savoir prévoir sa
taille afin que la classe string ne passe pas son temps à redimensionner
la chaîne , non ?
redimensionner la chaîne est souvent coûteux :
allocation + copie.
Pourquoi faire une telle chose ? L'intérêt de std::string (en
particulier) est justement de ne pas s'occuper de la taille du string et
de faire les opérations dessus, comme ça nous plaît. Ensuite, c'est lui
qui s'occupe de redimensionner tout ça en dynamique, lorsqu'il y en a
besoin...
C'est peut-être intéressant de temps en temps de savoir prévoir sa
taille afin que la classe string ne passe pas son temps à redimensionner
la chaîne , non ?
redimensionner la chaîne est souvent coûteux :
allocation + copie.
Pourquoi faire une telle chose ? L'intérêt de std::string (en
particulier) est justement de ne pas s'occuper de la taille du string et
de faire les opérations dessus, comme ça nous plaît. Ensuite, c'est lui
qui s'occupe de redimensionner tout ça en dynamique, lorsqu'il y en a
besoin...
C'est peut-être intéressant de temps en temps de savoir prévoir sa
taille afin que la classe string ne passe pas son temps à redimensionner
la chaîne , non ?
redimensionner la chaîne est souvent coûteux :
allocation + copie.
arg, en effet... On pourrait te reprocher d'avoir demandé à quelqu'un
d'autre de faire le projet :(
oki, voilà :
#include <algorithm>
class Extractor
{
public:
bool operator (char test)
{
if (test == '.') // un point => true
return true;
return false; // un croix ou autre chose => false
}
};
//....
// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
// il faut enlever les espaces du string, parce que le functor
// retournera false s'il trouve un espace ! Ce qui fausserait les index
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
Et voilà ! tu te retrouves à la fin avec le vector Result qui contient
la suite de bool que tu voulais au départ. En effet, std::transform
applique le functor à tous les éléments de la liste que tu lui donnes
(ici sInput.begin()->sInput.end()), et il met les résultats à la fin de
Result (grâce au back_inserter).
Donc, ça serait comme ça que je le ferais moi :) Mais après, tu as
malheureusement des contraintes... dommage :(
arg, en effet... On pourrait te reprocher d'avoir demandé à quelqu'un
d'autre de faire le projet :(
oki, voilà :
#include <algorithm>
class Extractor
{
public:
bool operator (char test)
{
if (test == '.') // un point => true
return true;
return false; // un croix ou autre chose => false
}
};
//....
// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
// il faut enlever les espaces du string, parce que le functor
// retournera false s'il trouve un espace ! Ce qui fausserait les index
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
Et voilà ! tu te retrouves à la fin avec le vector Result qui contient
la suite de bool que tu voulais au départ. En effet, std::transform
applique le functor à tous les éléments de la liste que tu lui donnes
(ici sInput.begin()->sInput.end()), et il met les résultats à la fin de
Result (grâce au back_inserter).
Donc, ça serait comme ça que je le ferais moi :) Mais après, tu as
malheureusement des contraintes... dommage :(
arg, en effet... On pourrait te reprocher d'avoir demandé à quelqu'un
d'autre de faire le projet :(
oki, voilà :
#include <algorithm>
class Extractor
{
public:
bool operator (char test)
{
if (test == '.') // un point => true
return true;
return false; // un croix ou autre chose => false
}
};
//....
// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
// il faut enlever les espaces du string, parce que le functor
// retournera false s'il trouve un espace ! Ce qui fausserait les index
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
Et voilà ! tu te retrouves à la fin avec le vector Result qui contient
la suite de bool que tu voulais au départ. En effet, std::transform
applique le functor à tous les éléments de la liste que tu lui donnes
(ici sInput.begin()->sInput.end()), et il met les résultats à la fin de
Result (grâce au back_inserter).
Donc, ça serait comme ça que je le ferais moi :) Mais après, tu as
malheureusement des contraintes... dommage :(
Nicolas Aunai wrote:"Michaël Monerau" a présenté l'énoncé suivant :J'en pense que tu devrais tout de même prendre la chaîne dans un
std::string. Puis tu fais une fonction qui supprime les espaces dans ta
chaîne après(tout simple, un s.find_first_of (' ') avec un
s.erase(...)). Je trouve ça plus propre ;)
ben je vois aussi que ça fait plus propre, le problème étant que tout ça
est pour un projet (de deug) et mon code utilise déjà des notions tout a
fait hors programme...
arg, en effet... On pourrait te reprocher d'avoir demandé à quelqu'un
d'autre de faire le projet :(Ca transformerait tout
seul la chaîne (avec ou sans les espaces, selon tes envies, moi je
ferais avec) en un vector<bool>, ou ce que tu veux d'autre. Si tu veux,
je peux te faire un petit exemple si tu ne connais pas encore ;-)
bah je veux bien ouais c'est sympa, mais ça sera uniquement pour ma
culture perso je pense...
oki, voilà :
#include <algorithm>
class Extractor
{
public:
bool operator (char test)
{
if (test == '.') // un point => true
return true;
return false; // un croix ou autre chose => false
}
};
//....
// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
Nicolas Aunai wrote:
"Michaël Monerau" a présenté l'énoncé suivant :
J'en pense que tu devrais tout de même prendre la chaîne dans un
std::string. Puis tu fais une fonction qui supprime les espaces dans ta
chaîne après(tout simple, un s.find_first_of (' ') avec un
s.erase(...)). Je trouve ça plus propre ;)
ben je vois aussi que ça fait plus propre, le problème étant que tout ça
est pour un projet (de deug) et mon code utilise déjà des notions tout a
fait hors programme...
arg, en effet... On pourrait te reprocher d'avoir demandé à quelqu'un
d'autre de faire le projet :(
Ca transformerait tout
seul la chaîne (avec ou sans les espaces, selon tes envies, moi je
ferais avec) en un vector<bool>, ou ce que tu veux d'autre. Si tu veux,
je peux te faire un petit exemple si tu ne connais pas encore ;-)
bah je veux bien ouais c'est sympa, mais ça sera uniquement pour ma
culture perso je pense...
oki, voilà :
#include <algorithm>
class Extractor
{
public:
bool operator (char test)
{
if (test == '.') // un point => true
return true;
return false; // un croix ou autre chose => false
}
};
//....
// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
Nicolas Aunai wrote:"Michaël Monerau" a présenté l'énoncé suivant :J'en pense que tu devrais tout de même prendre la chaîne dans un
std::string. Puis tu fais une fonction qui supprime les espaces dans ta
chaîne après(tout simple, un s.find_first_of (' ') avec un
s.erase(...)). Je trouve ça plus propre ;)
ben je vois aussi que ça fait plus propre, le problème étant que tout ça
est pour un projet (de deug) et mon code utilise déjà des notions tout a
fait hors programme...
arg, en effet... On pourrait te reprocher d'avoir demandé à quelqu'un
d'autre de faire le projet :(Ca transformerait tout
seul la chaîne (avec ou sans les espaces, selon tes envies, moi je
ferais avec) en un vector<bool>, ou ce que tu veux d'autre. Si tu veux,
je peux te faire un petit exemple si tu ne connais pas encore ;-)
bah je veux bien ouais c'est sympa, mais ça sera uniquement pour ma
culture perso je pense...
oki, voilà :
#include <algorithm>
class Extractor
{
public:
bool operator (char test)
{
if (test == '.') // un point => true
return true;
return false; // un croix ou autre chose => false
}
};
//....
// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
DINH Viêt Hoà wrote:C'est peut-être intéressant de temps en temps de savoir prévoir sa
taille afin que la classe string ne passe pas son temps à redimensionner
la chaîne , non ?
redimensionner la chaîne est souvent coûteux :
allocation + copie.
Je pense que c'est une optimisation qui n'a lieu d'être que dans des
boucles très souvent exécutées... Et dans ce cas-là, je serais plutôt
pour une utilisation du 'reserve' du vector (en utilisant un
vector<char> si l'usage s'y prête). Je ne crois pas que std::string ne
présente de 'reserve', mais c'est à vérifier tout de même...
DINH Viêt Hoà wrote:
C'est peut-être intéressant de temps en temps de savoir prévoir sa
taille afin que la classe string ne passe pas son temps à redimensionner
la chaîne , non ?
redimensionner la chaîne est souvent coûteux :
allocation + copie.
Je pense que c'est une optimisation qui n'a lieu d'être que dans des
boucles très souvent exécutées... Et dans ce cas-là, je serais plutôt
pour une utilisation du 'reserve' du vector (en utilisant un
vector<char> si l'usage s'y prête). Je ne crois pas que std::string ne
présente de 'reserve', mais c'est à vérifier tout de même...
DINH Viêt Hoà wrote:C'est peut-être intéressant de temps en temps de savoir prévoir sa
taille afin que la classe string ne passe pas son temps à redimensionner
la chaîne , non ?
redimensionner la chaîne est souvent coûteux :
allocation + copie.
Je pense que c'est une optimisation qui n'a lieu d'être que dans des
boucles très souvent exécutées... Et dans ce cas-là, je serais plutôt
pour une utilisation du 'reserve' du vector (en utilisant un
vector<char> si l'usage s'y prête). Je ne crois pas que std::string ne
présente de 'reserve', mais c'est à vérifier tout de même...
=?ISO-8859-15?Q?Michaël_Monerau?= wrote in
news:s5lyb.29922$:std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
Le erase-remove ne marche pas ? Tant qu'à faire ...
sInput.erase(std::remove(sInput.begin(),sInput.end(),' '), sInput.end());
On peut imaginer aussi un transform_if, fils caché entre std::transform et
copy_if l'algo perdu, pour directement passer de la chaine récupérée (avec
espaces) au vecteur de booléens.
=?ISO-8859-15?Q?Michaël_Monerau?= <cort@meloo.com> wrote in
news:s5lyb.29922$361.29351@news.chello.at:
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
Le erase-remove ne marche pas ? Tant qu'à faire ...
sInput.erase(std::remove(sInput.begin(),sInput.end(),' '), sInput.end());
On peut imaginer aussi un transform_if, fils caché entre std::transform et
copy_if l'algo perdu, pour directement passer de la chaine récupérée (avec
espaces) au vecteur de booléens.
=?ISO-8859-15?Q?Michaël_Monerau?= wrote in
news:s5lyb.29922$:std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
Le erase-remove ne marche pas ? Tant qu'à faire ...
sInput.erase(std::remove(sInput.begin(),sInput.end(),' '), sInput.end());
On peut imaginer aussi un transform_if, fils caché entre std::transform et
copy_if l'algo perdu, pour directement passer de la chaine récupérée (avec
espaces) au vecteur de booléens.
"Michaël Monerau" avait soumis l'idée :// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
là je ne suis pas trop... pourquoi "cin.getline" ? pourquoi pas cin >>
sInput tout simplement ? bon ok je connais pas trop cin et ses
méthodes... pas plus que cout d'ailleurs
// il faut enlever les espaces du string, parce que le functor
// retournera false s'il trouve un espace ! Ce qui fausserait les index
un functor c'est un objet avec une redéfinition de l'opérateur '()',
quel est sont intérêt ici ?
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
je comprends pas trop le functor en dernier paramètre de transform(), je
n'ai pas vu la création de l'objet 'BoolExtractor', est-ce un oubli ?
Donc, ça serait comme ça que je le ferais moi :) Mais après, tu as
malheureusement des contraintes... dommage :(
j'peux te dire que dans l'absolu je m'en fout des contraintes, si un
prof est intelligent je vois pas pourquoi un étudiant serait sanctionné
pour avoir plus de connaissances que le cours. Et s'il est sanctionné
alors tant pis pour le prof, l'étudiant lui, aura au moins appris qqch.
le fait est qu'il faut tout de même *bien* maitriser les codes "hors
programme" pour les mettre dans son projet, sinon on est pas crédible,
d'où ma rétissance sur les functor et transform que je ne connais pas bien.
"Michaël Monerau" avait soumis l'idée :
// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
là je ne suis pas trop... pourquoi "cin.getline" ? pourquoi pas cin >>
sInput tout simplement ? bon ok je connais pas trop cin et ses
méthodes... pas plus que cout d'ailleurs
// il faut enlever les espaces du string, parce que le functor
// retournera false s'il trouve un espace ! Ce qui fausserait les index
un functor c'est un objet avec une redéfinition de l'opérateur '()',
quel est sont intérêt ici ?
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
je comprends pas trop le functor en dernier paramètre de transform(), je
n'ai pas vu la création de l'objet 'BoolExtractor', est-ce un oubli ?
Donc, ça serait comme ça que je le ferais moi :) Mais après, tu as
malheureusement des contraintes... dommage :(
j'peux te dire que dans l'absolu je m'en fout des contraintes, si un
prof est intelligent je vois pas pourquoi un étudiant serait sanctionné
pour avoir plus de connaissances que le cours. Et s'il est sanctionné
alors tant pis pour le prof, l'étudiant lui, aura au moins appris qqch.
le fait est qu'il faut tout de même *bien* maitriser les codes "hors
programme" pour les mettre dans son projet, sinon on est pas crédible,
d'où ma rétissance sur les functor et transform que je ne connais pas bien.
"Michaël Monerau" avait soumis l'idée :// On prend un std::string avec les espaces en input
std::string sInput;
// voir pour cin.getline, je ne me souviens plus exactement
// les arguments...
là je ne suis pas trop... pourquoi "cin.getline" ? pourquoi pas cin >>
sInput tout simplement ? bon ok je connais pas trop cin et ses
méthodes... pas plus que cout d'ailleurs
// il faut enlever les espaces du string, parce que le functor
// retournera false s'il trouve un espace ! Ce qui fausserait les index
un functor c'est un objet avec une redéfinition de l'opérateur '()',
quel est sont intérêt ici ?
std::string::iterator itFound;
while ((itFound = sInput.find_first_of (' ')) != sInput.npos)
// un espace est trouvé, on le supprime
sInput.erase (itFound);
std::vector<bool> Result;
std::transform (sInput.begin(), sInput.end(),
std::back_inserter<vector<bool>(Result), BoolExtractor ());
je comprends pas trop le functor en dernier paramètre de transform(), je
n'ai pas vu la création de l'objet 'BoolExtractor', est-ce un oubli ?
Donc, ça serait comme ça que je le ferais moi :) Mais après, tu as
malheureusement des contraintes... dommage :(
j'peux te dire que dans l'absolu je m'en fout des contraintes, si un
prof est intelligent je vois pas pourquoi un étudiant serait sanctionné
pour avoir plus de connaissances que le cours. Et s'il est sanctionné
alors tant pis pour le prof, l'étudiant lui, aura au moins appris qqch.
le fait est qu'il faut tout de même *bien* maitriser les codes "hors
programme" pour les mettre dans son projet, sinon on est pas crédible,
d'où ma rétissance sur les functor et transform que je ne connais pas bien.
Quitte a utiliser getline, pourquoi ne pas utiliser le manipulateur
ws pour virer les espace.
En effet, j'y ai pensé. Mais comme je ne l'ai jamais utilisé, je ne
voulais pas risquer de dire une chose fausse. Comme l'utiliserais-tu alors ?
Quitte a utiliser getline, pourquoi ne pas utiliser le manipulateur
ws pour virer les espace.
En effet, j'y ai pensé. Mais comme je ne l'ai jamais utilisé, je ne
voulais pas risquer de dire une chose fausse. Comme l'utiliserais-tu alors ?
Quitte a utiliser getline, pourquoi ne pas utiliser le manipulateur
ws pour virer les espace.
En effet, j'y ai pensé. Mais comme je ne l'ai jamais utilisé, je ne
voulais pas risquer de dire une chose fausse. Comme l'utiliserais-tu alors ?
