je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet effectivement
lus ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble. Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf. J'ai du mal a voir la coherence, surtout quand on considere qu'il parle de faire des mouvements avant, ce qui impliquerait que rien n'est bufferise a ce moment.
Je n'ai pas compris ce que faisait readsome alors. Désolé pour le mauvais conseil.
J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que readsome ne lira pas dans le fichier mais uniquement dans le buffer associé ?
Ma compréhension était que readsome ne levait pas eofbit quand il arrivait a la fin du fichier mais a part cela etait équivalent à un read et gcount dans le cas d'un fichier.
Michael
Michael DOUBEZ <michael.doubez@free.fr> writes:
Michael DOUBEZ <michael.doubez@free.fr> writes:
je voudrais savoir si mon code est correct, où s'il existe une autre
méthode
file_ est un fstream
size_t sizeP0;
char* ptr=new char[size];
the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet effectivement
lus ou
utilises readsome()?
Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble.
Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf.
J'ai du mal a voir la coherence, surtout quand on considere qu'il
parle de
faire des mouvements avant, ce qui impliquerait que rien n'est
bufferise a
ce moment.
Je n'ai pas compris ce que faisait readsome alors.
Désolé pour le mauvais conseil.
J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que
readsome ne lira pas dans le fichier mais uniquement dans le buffer
associé ?
Ma compréhension était que readsome ne levait pas eofbit quand il
arrivait a la fin du fichier mais a part cela etait équivalent à un read
et gcount dans le cas d'un fichier.
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet effectivement
lus ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble. Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf. J'ai du mal a voir la coherence, surtout quand on considere qu'il parle de faire des mouvements avant, ce qui impliquerait que rien n'est bufferise a ce moment.
Je n'ai pas compris ce que faisait readsome alors. Désolé pour le mauvais conseil.
J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que readsome ne lira pas dans le fichier mais uniquement dans le buffer associé ?
Ma compréhension était que readsome ne levait pas eofbit quand il arrivait a la fin du fichier mais a part cela etait équivalent à un read et gcount dans le cas d'un fichier.
Michael
Jean-Marc Bourguet
James Kanze writes:
On Nov 13, 9:06 pm, Jean-Marc Bourguet wrote:
Michael DOUBEZ writes:
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet effectivement lus ou utilises readsome()?
Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent rdbuf()->in_avail() : parce qu'ils en ont mal compris la sémantique.
Si au moins in_avail retournait egptr() - gptr() + showmanyc()
(La flemme de regarder, comment showmanyc interagit avec les mapping CR/LF->LF? Mal je suppose pour rendre encore la chose encore moins utilisable.)
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
James Kanze <james.kanze@gmail.com> writes:
On Nov 13, 9:06 pm, Jean-Marc Bourguet <j...@bourguet.org> wrote:
Michael DOUBEZ <michael.dou...@free.fr> writes:
je voudrais savoir si mon code est correct, où s'il existe une autre
méthode
file_ est un fstream
size_t sizeP0;
char* ptr=new char[size];
the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet
effectivement lus ou utilises readsome()?
Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent
rdbuf()->in_avail() : parce qu'ils en ont mal compris la
sémantique.
Si au moins in_avail retournait egptr() - gptr() + showmanyc()
(La flemme de regarder, comment showmanyc interagit avec les mapping
CR/LF->LF? Mal je suppose pour rendre encore la chose encore moins
utilisable.)
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet effectivement lus ou utilises readsome()?
Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent rdbuf()->in_avail() : parce qu'ils en ont mal compris la sémantique.
Si au moins in_avail retournait egptr() - gptr() + showmanyc()
(La flemme de regarder, comment showmanyc interagit avec les mapping CR/LF->LF? Mal je suppose pour rendre encore la chose encore moins utilisable.)
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Jean-Marc Bourguet
Michael DOUBEZ writes:
Michael DOUBEZ writes:
Michael DOUBEZ writes:
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet effectivement lus
ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble. Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf. J'ai du mal a voir la coherence, surtout quand on considere qu'il parle de faire des mouvements avant, ce qui impliquerait que rien n'est bufferise a ce moment. Je n'ai pas compris ce que faisait readsome alors.
Désolé pour le mauvais conseil.
J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que readsome ne lira pas dans le fichier mais uniquement dans le buffer associé ?
Ca peut lire dans le fichier si le buffer est vide et que showmanyc retourne quelque chose > 0.
Ma compréhension était que readsome ne levait pas eofbit quand il arrivait a la fin du fichier mais a part cela etait équivalent à un read et gcount dans le cas d'un fichier.
eofbit peut etre mis. Sinon readsome fait un read de max(in_avail, count) et retourne gcount().
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Michael DOUBEZ <michael.doubez@free.fr> writes:
Michael DOUBEZ <michael.doubez@free.fr> writes:
Michael DOUBEZ <michael.doubez@free.fr> writes:
je voudrais savoir si mon code est correct, où s'il existe une autre
méthode
file_ est un fstream
size_t sizeP0;
char* ptr=new char[size];
the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet effectivement lus
ou
utilises readsome()?
Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble.
Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf.
J'ai du mal a voir la coherence, surtout quand on considere qu'il parle
de
faire des mouvements avant, ce qui impliquerait que rien n'est bufferise
a
ce moment.
Je n'ai pas compris ce que faisait readsome alors.
Désolé pour le mauvais conseil.
J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que
readsome ne lira pas dans le fichier mais uniquement dans le buffer associé
?
Ca peut lire dans le fichier si le buffer est vide et que showmanyc
retourne quelque chose > 0.
Ma compréhension était que readsome ne levait pas eofbit quand il
arrivait a la fin du fichier mais a part cela etait équivalent à un read
et gcount dans le cas d'un fichier.
eofbit peut etre mis. Sinon readsome fait un read de max(in_avail, count)
et retourne gcount().
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet effectivement lus
ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble. Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf. J'ai du mal a voir la coherence, surtout quand on considere qu'il parle de faire des mouvements avant, ce qui impliquerait que rien n'est bufferise a ce moment. Je n'ai pas compris ce que faisait readsome alors.
Désolé pour le mauvais conseil.
J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que readsome ne lira pas dans le fichier mais uniquement dans le buffer associé ?
Ca peut lire dans le fichier si le buffer est vide et que showmanyc retourne quelque chose > 0.
Ma compréhension était que readsome ne levait pas eofbit quand il arrivait a la fin du fichier mais a part cela etait équivalent à un read et gcount dans le cas d'un fichier.
eofbit peut etre mis. Sinon readsome fait un read de max(in_avail, count) et retourne gcount().
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Michael DOUBEZ
On Nov 13, 9:06 pm, Jean-Marc Bourguet wrote:
Michael DOUBEZ writes:
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet effectivement lus ou utilises readsome()?
Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent rdbuf()->in_avail() : parce qu'ils en ont mal compris la sémantique.
in_avail() retourne le nombre de caractères pouvant être lut par read sans bloquer. Je ne vois pas en quoi c'est incompatible avec readsome sur un fichier, le nombre de caractères pouvant être lut etant bien ceux entre le curseur courant et la fin du fichier.
streamsize readsome(char_type* s, streamsize n);
Effects: If !good() calls setstate(failbit) which may throw an exception, and return. Otherwise extracts characters and stores them into successive locations of an array whose first element is designated by s . If rdbuf()->in_avail() == -1, calls setstate(eofbit) (which may throw ios_base::failure (lib.iostate.flags)), and extracts no characters;
* If rdbuf()->in_avail() == 0, extracts no characters
* If rdbuf()->in_avail() > 0, extracts min(rdbuf()->in_avail(),n)).
Ca n'a pas tellement d'intérêt en dehors des stream que l'on sait interactive il me semble.
Même quand on connaît le flux interactif, je ne suis pas sûr de son utilité. Après un getline(), par exemple, il y a de fortes chances qu'elle ne lit rien (au moins sous Unix ou Windows). Et si l'utilisateur est assez pervers pour entrer des lignes plus longues que le buffer, il risque de ne pas fonctionner comme on veut non plus.
C'est vrai que les alternative à readline (comme dans un editeur texte) sont plutot de la lecture caractère/caractère.
Michael
On Nov 13, 9:06 pm, Jean-Marc Bourguet <j...@bourguet.org> wrote:
Michael DOUBEZ <michael.dou...@free.fr> writes:
je voudrais savoir si mon code est correct, où s'il existe une autre
méthode
file_ est un fstream
size_t sizeP0;
char* ptr=new char[size];
the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet
effectivement lus ou utilises readsome()?
Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent
rdbuf()->in_avail() : parce qu'ils en ont mal compris la
sémantique.
in_avail() retourne le nombre de caractères pouvant être lut par read
sans bloquer. Je ne vois pas en quoi c'est incompatible avec readsome
sur un fichier, le nombre de caractères pouvant être lut etant bien ceux
entre le curseur courant et la fin du fichier.
streamsize readsome(char_type* s, streamsize n);
Effects: If !good() calls setstate(failbit) which may throw an
exception, and return. Otherwise extracts characters and stores them
into successive locations of an array whose first element is designated
by s . If rdbuf()->in_avail() == -1, calls setstate(eofbit) (which may
throw ios_base::failure (lib.iostate.flags)), and extracts no characters;
* If rdbuf()->in_avail() == 0, extracts no characters
* If rdbuf()->in_avail() > 0, extracts min(rdbuf()->in_avail(),n)).
Ca n'a pas tellement d'intérêt en dehors des stream que l'on
sait interactive il me semble.
Même quand on connaît le flux interactif, je ne suis pas sûr de
son utilité. Après un getline(), par exemple, il y a de fortes
chances qu'elle ne lit rien (au moins sous Unix ou Windows). Et
si l'utilisateur est assez pervers pour entrer des lignes plus
longues que le buffer, il risque de ne pas fonctionner comme on
veut non plus.
C'est vrai que les alternative à readline (comme dans un editeur texte)
sont plutot de la lecture caractère/caractère.
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet effectivement lus ou utilises readsome()?
Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent rdbuf()->in_avail() : parce qu'ils en ont mal compris la sémantique.
in_avail() retourne le nombre de caractères pouvant être lut par read sans bloquer. Je ne vois pas en quoi c'est incompatible avec readsome sur un fichier, le nombre de caractères pouvant être lut etant bien ceux entre le curseur courant et la fin du fichier.
streamsize readsome(char_type* s, streamsize n);
Effects: If !good() calls setstate(failbit) which may throw an exception, and return. Otherwise extracts characters and stores them into successive locations of an array whose first element is designated by s . If rdbuf()->in_avail() == -1, calls setstate(eofbit) (which may throw ios_base::failure (lib.iostate.flags)), and extracts no characters;
* If rdbuf()->in_avail() == 0, extracts no characters
* If rdbuf()->in_avail() > 0, extracts min(rdbuf()->in_avail(),n)).
Ca n'a pas tellement d'intérêt en dehors des stream que l'on sait interactive il me semble.
Même quand on connaît le flux interactif, je ne suis pas sûr de son utilité. Après un getline(), par exemple, il y a de fortes chances qu'elle ne lit rien (au moins sous Unix ou Windows). Et si l'utilisateur est assez pervers pour entrer des lignes plus longues que le buffer, il risque de ne pas fonctionner comme on veut non plus.
C'est vrai que les alternative à readline (comme dans un editeur texte) sont plutot de la lecture caractère/caractère.
Michael
Michael DOUBEZ
James Kanze writes:
On Nov 13, 9:06 pm, Jean-Marc Bourguet wrote:
Michael DOUBEZ writes:
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet
effectivement lus ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent
rdbuf()->in_avail() : parce qu'ils en ont mal compris la sémantique.
Si au moins in_avail retournait egptr() - gptr() + showmanyc()
(La flemme de regarder, comment showmanyc interagit avec les mapping CR/LF->LF? Mal je suppose pour rendre encore la chose encore moins utilisable.)
Est ce que read fait la conversion CR/LF->LF ?
Michael
James Kanze <james.kanze@gmail.com> writes:
On Nov 13, 9:06 pm, Jean-Marc Bourguet <j...@bourguet.org> wrote:
Michael DOUBEZ <michael.dou...@free.fr> writes:
je voudrais savoir si mon code est correct, où s'il existe une autre
méthode
file_ est un fstream
size_t sizeP0;
char* ptr=new char[size];
the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet
effectivement lus ou utilises readsome()?
Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent
rdbuf()->in_avail() : parce qu'ils en ont mal compris la
sémantique.
Si au moins in_avail retournait egptr() - gptr() + showmanyc()
(La flemme de regarder, comment showmanyc interagit avec les mapping
CR/LF->LF? Mal je suppose pour rendre encore la chose encore moins
utilisable.)
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet
effectivement lus ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte?
Sans doute pour la même raison que beaucoup de gens utilisent
rdbuf()->in_avail() : parce qu'ils en ont mal compris la sémantique.
Si au moins in_avail retournait egptr() - gptr() + showmanyc()
(La flemme de regarder, comment showmanyc interagit avec les mapping CR/LF->LF? Mal je suppose pour rendre encore la chose encore moins utilisable.)
Est ce que read fait la conversion CR/LF->LF ?
Michael
Michael DOUBEZ
Michael DOUBEZ writes:
Michael DOUBEZ writes:
Michael DOUBEZ writes:
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet effectivement lus
ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble. Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf.
J'ai du mal a voir la coherence, surtout quand on considere qu'il parle de faire des mouvements avant, ce qui impliquerait que rien n'est bufferise a ce moment. Je n'ai pas compris ce que faisait readsome alors.
Désolé pour le mauvais conseil. J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que
readsome ne lira pas dans le fichier mais uniquement dans le buffer associé ?
Ca peut lire dans le fichier si le buffer est vide et que showmanyc retourne quelque chose > 0.
Ma compréhension était que readsome ne levait pas eofbit quand il arrivait a la fin du fichier mais a part cela etait équivalent à un read et gcount dans le cas d'un fichier.
eofbit peut etre mis. Sinon readsome fait un read de max(in_avail, count) et retourne gcount().
D'accord, le problème est sur in_avail() a un état donné du flux.
streamsize in_avail();
If a read position is available, the member function returns egptr() - gptr(). Otherwise, it returns showmanyc().
Dans le cas de l'OP, un readsome(buf,500) ne serait donc pas garanti de lire dans le fichier si le get pointer est defini et contient des données.
Merci.
Michael
Michael DOUBEZ <michael.doubez@free.fr> writes:
Michael DOUBEZ <michael.doubez@free.fr> writes:
Michael DOUBEZ <michael.doubez@free.fr> writes:
je voudrais savoir si mon code est correct, où s'il existe une autre
méthode
file_ est un fstream
size_t sizeP0;
char* ptr=new char[size];
the_file.read(ptr,size);
Utilises gcount() pour connaitre le nombre d'octet effectivement lus
ou
utilises readsome()?
Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble.
Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf.
J'ai du mal a voir la coherence, surtout quand on considere qu'il parle
de
faire des mouvements avant, ce qui impliquerait que rien n'est bufferise
a
ce moment.
Je n'ai pas compris ce que faisait readsome alors.
Désolé pour le mauvais conseil.
J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que
readsome ne lira pas dans le fichier mais uniquement dans le buffer associé
?
Ca peut lire dans le fichier si le buffer est vide et que showmanyc
retourne quelque chose > 0.
Ma compréhension était que readsome ne levait pas eofbit quand il
arrivait a la fin du fichier mais a part cela etait équivalent à un read
et gcount dans le cas d'un fichier.
eofbit peut etre mis. Sinon readsome fait un read de max(in_avail, count)
et retourne gcount().
je voudrais savoir si mon code est correct, où s'il existe une autre méthode file_ est un fstream size_t sizeP0; char* ptr=new char[size]; the_file.read(ptr,size); Utilises gcount() pour connaitre le nombre d'octet effectivement lus
ou utilises readsome()? Pourquoi utiliser readsome dans ce contexte? Ca n'a pas tellement
d'intérêt en dehors des stream que l'on sait interactive il me semble. Pour etre coherent avec une lecture en fin de fichier.
readsome ne fait que lire ce qui a deja ete bufferise dans le streambuf.
J'ai du mal a voir la coherence, surtout quand on considere qu'il parle de faire des mouvements avant, ce qui impliquerait que rien n'est bufferise a ce moment. Je n'ai pas compris ce que faisait readsome alors.
Désolé pour le mauvais conseil. J'aimerais être sûr d'avoir compris ce que tu as dit: tu veux dire que
readsome ne lira pas dans le fichier mais uniquement dans le buffer associé ?
Ca peut lire dans le fichier si le buffer est vide et que showmanyc retourne quelque chose > 0.
Ma compréhension était que readsome ne levait pas eofbit quand il arrivait a la fin du fichier mais a part cela etait équivalent à un read et gcount dans le cas d'un fichier.
eofbit peut etre mis. Sinon readsome fait un read de max(in_avail, count) et retourne gcount().
En plus, tu me l'as déjà dit il y a quelques jours sur une autre question. Mais je m'entête dans mes mauvaises habitudes...
Essaie d'imaginer tous les cas où le delete[] peut ne pas être appelé, et je suis sûr que tu seras vite convaincu d'éviter new char[].
Marc G
Je connais exactement la structure du fichier. Quand je lis une grosse structure (avec de nombreux appels à read), je trouve lourd de vérifier le nombre d'octects lus à chaque fois.
Qu'est-ce qui se passe dans le code suivant si la lecture de x échoue ? y-a-t-il une exception lors de la tentative de lecture de y, ou la fonction ne fait simplement rien compte tenu de l'état du flux ?
je préfèrerait vérifier l'état du flux une fois pour toutes à la fin (sachant que normalement il n'y a jamais de problème !)
autre question :
operator !() est surchargé pour fstream (entre-autres) est-ce que operator bool() est surchargé de la même manière (mon compilateur l'accepte) , ie if (input) ... équivaut à if (!!input) ? merci Marc
Je connais exactement la structure du fichier.
Quand je lis une grosse structure (avec de nombreux appels à read),
je trouve lourd de vérifier le nombre d'octects lus à chaque fois.
Qu'est-ce qui se passe dans le code suivant si la lecture de x échoue ?
y-a-t-il une exception lors de la tentative de lecture de y, ou la fonction
ne fait simplement rien compte tenu de l'état du flux ?
je préfèrerait vérifier l'état du flux une fois pour toutes à la fin
(sachant que normalement il n'y a jamais de problème !)
autre question :
operator !() est surchargé pour fstream (entre-autres)
est-ce que operator bool() est surchargé de la même manière (mon compilateur
l'accepte) , ie
if (input) ...
équivaut à
if (!!input)
?
merci
Marc
Je connais exactement la structure du fichier. Quand je lis une grosse structure (avec de nombreux appels à read), je trouve lourd de vérifier le nombre d'octects lus à chaque fois.
Qu'est-ce qui se passe dans le code suivant si la lecture de x échoue ? y-a-t-il une exception lors de la tentative de lecture de y, ou la fonction ne fait simplement rien compte tenu de l'état du flux ?
je préfèrerait vérifier l'état du flux une fois pour toutes à la fin (sachant que normalement il n'y a jamais de problème !)
autre question :
operator !() est surchargé pour fstream (entre-autres) est-ce que operator bool() est surchargé de la même manière (mon compilateur l'accepte) , ie if (input) ... équivaut à if (!!input) ? merci Marc
Marc G
merci, je vois que je ne suis pas le seul lève-tôt :-)
merci,
je vois que je ne suis pas le seul lève-tôt :-)
