Newsgroup: it.comp.lang.c++
Titolo: cin.getline() dopo il cin

Prima di tutto, buona domenica a tutti...
Ho riscontrato questo strano problema utilizzando di seguito cin, e poi 
cin.getline;
In pratica se immetto una variabile tramite cin, e poi dopo c'č cin.getline, 
oppure una serie
di cin getline, il primo di questi mi viene saltato...
Ecco un esempio:
#include <iostream>
typedef char Stringa20[20];
using namespace std;
int main(){
int volte;
Stringa20 nome;
cout << "Quante volte vuoi ripetere il ciclo?  ";
cin >> volte;      //questo č il cin che sembra provochi il casino...
cout << endl;
cout << "Inserisci Il tuo nome";
cin.getline(nome, 20);
/* l'attesa di input qui sopra viene saltata, e ho notato che questo avviene 
per
   la presenza del cin qlc linea piů sopra... infatti levandolo e tutto ok.
   Mi piacerebbe capire perchč accade, e quale puň essere il modo di evitare
   questo problema ( che nn sia quello di usare una istruzione cin.getline a 
vuoto prima *_*  !! )...
*/
system("PAUSE");
return 0;
}
Grazie in anticipo per l'aiuto,
Aleander 

Prima di tutto, buona domenica a tutti...
Ho riscontrato questo strano problema utilizzando di seguito cin, e poi
cin.getline;
in pratica se immetto una variabile tramite cin, e poi dopo c'č cin.getline,
oppure una serie di cin getline, il primo di questi mi viene saltato...
Ecco un esempio:
#include <iostream>
typedef char Stringa20[20];
using namespace std;
int main(){
int volte;
Stringa20 nome;
cout << "Quante volte vuoi ripetere il ciclo?  ";
cin >> volte;      //questo č il cin che sembra provochi il casino...
cout << endl;
cout << "Inserisci il tuo nome: ";
cin.getline(nome, 20);
/* l'attesa di input qui sopra viene saltata, e ho notato che questo avviene
   per la presenza del cin qlc linea piů sopra... infatti levandolo č tutto 


 */
Guarda, io cin.getline non l'ho mai usato e non so se coincide con getline.
Se ti basta evitare il problema allora semplicemente fai:
string s;
getline (std::cin, s, '\n');
e l'input memorizza tutto in s fino a quando non premi invio.
Se invece vuoi sapere perche' cin.getline() si comporta in quel modo allora
speriamo che qualcun'altro legga il tuo post :P
Ciao

 ha scritto nel messaggio 
news:422ad...@x-privat.org...

Buongiorno,
guarda Noixe non credo che sia per quello perche' la funzione cin.getline 
prevede per default il delimitatore di stringa \n. Quindi scrivere 
cin.getline(stringa, num_max_di_caratteri, delimitatore'\n'); equivale a non 
mettere il delimitatore \n stesso. Mi permetto di dire cio' solo perchè ho 
trovato lo stesso problema che si e' posto il collega Aleander e non sono 
riuscito a risolverlo nemmeno io.
grazie per l'attenzione
Cloud Strife 

 riuscito a risolverlo nemmeno io.
Se ti riferisci all'uso delle stringhe rispetto agli array di char quello e'
soprattutto un consiglio da applicare in generale. Per risolvere il vostro
problema la soluzione piu immediata che ho trovato e' quella di usare solo
getline senza cin, pero siccome getline acceta solo string si deve
convertire il numero in int. Scrissi tempo fa una semplice funzione che
converte da string a double e una piccola parte di essa posso applicarla
agli int:
#include <iostream>
#include <string>
int String2Int(string s) {
 int n = 0, x = 1;
 for (int i = 0; i < s.size(); i++) {
      n += (s[s.size() - i - 1] - 48) * x;
      x *= 10;
  };
 return n;
};
int main() {
 int n = 0;
 string s, nome;
 std::cout << "Numero di cicli?" << std::endl;
 getline(std::cin, s, '\n');
 n = String2Int(s);
 while (n--) {
  std::cout << "Nome?" << std::endl;
  getline(std::cin, nome, '\n');
 };
 return 0;
}
Ciao

 cin.getline;
#include <iostream>
typedef char Stringa20[20];
using namespace std;
int main(){
int volte;
Stringa20 nome;
cout << "Quante volte vuoi ripetere il ciclo?  ";
cin >> volte;      //questo č il cin che sembra provochi il casino...
cout << endl;
cout << "Inserisci il tuo nome: ";
while ( cin.get() != '\n' );
cin.getline(nome, 20);
/* l'attesa di input qui sopra viene saltata, e ho notato che questo
avviene
   per la presenza del cin qlc linea piů sopra... infatti levandolo č
tutto 
ok.
   Mi piacerebbe capire perchč accade, e quale puň essere il modo di
evitare
   questo problema ( che nn sia quello di usare una istruzione
cin.getline a
   vuoto prima *_*  !! )...
*/
system("PAUSE");
return 0;
}
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

 cin.getline(nome, 20);
Ah, bastava mettere quel while? Pensavo che si dovesse svuotare il buffer o
roba simile.

 cin.getline(nome, 20);
Un'altra cosa: come mai se si usano 2 cin >> in sequenza (cioe' leggendo i 2
inpunt con cin e senza cin.getline()) non c'e' nessun salto?
Ciao

 inpunt con cin e senza cin.getline()) non c'e' nessun salto?
Va be 3 post per dire una cosa :(
Cmq, per caso cin dopo aver premuto invio, lascia un carattere di newline?
Infatti sia cin.getline che getline escono subito se messi subito dopo un
cin.

 wrote:

perqué il secondo cin<<i mangia il '\n' della prima riga.
cin<<a<<b<<c;
Input:
 1  <ENTER>2 <ENTER> 3 <ENTER>
cin<<a mangia " " e legge "1"
cin<<b mangia "  <ENTER>" e legge "2"
cin<<c mangia " <ENTER> " e legge "3"
-- 
Horst


Non sei mica così gentile da spiegarmi anche il senso di ciò?
Cioè nn è lo stesso che mettere un cin.getline() a vuoto ?
(la qual cosa reputo poco corretta formalmente o, come si dalle mie parti, 
un pezzotto)
Aleander 

 buffer o roba simile.
Per l'appunto quel while svuota lo stream di input fino al '\n'.


 cin.getline;
Mi han consigliato questa soluzione, ma nn ho avuto modo di chiedere 
spiegazioni:
#include <iostream>
#include <ios>
typedef char Stringa20[20];
using namespace std;
int main(){
int volte;
Stringa20 nome;
cout << "Quante volte vuoi ripetere il ciclo?  ";
cin >> volte;   //questo è il cin che sembra provochi il casino...
cout << endl;
cout << "Inserisci il tuo nome: ";
cin.ignore(numeric_limits<streamsize>::max(),'\n');
cin.getline(nome, 20);
system("PAUSE");
return 0;
}
In pratica si trattava di includere <ios> e di aggiungere questa riga:
cin.ignore(numeric_limits<streamsize>::max(),'\n');
Qualcuno sa di che si tratta?
tnx,
Aleander 

 newline?
Certo.


 cin.ignore(numeric_limits<streamsize>::max(),'\n');
Ottima. Migliore della mia.


 Ottima. Migliore della mia.
Non conosco perň la funzione cin.ignore() e da com'č scritta
nn si intuisce un granchč cosa faccia...
e poi max() che fa?

 EMG
Ciao,
Mi sembra che le domande sul corretto utilizzo di getline() dopo un "cin >>
var" siano sempre le stesse in questo periodo. Io stesso, se ricordo bene,
ho trattato questo problema più volte solo negli ultimi due mesi su questo
NG, proponendo anche l'utilizzo di cin.ignore() come ha fatto Aleander.
Hai capito dove voglio arrivare? Evitiamo di spiegare sempre la stessa cosa
e trattiamo il problema sulle FAQ. Che ne pensi/pensate?
Saluti,
fabio de francesco
(fabiomdf)
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 cin.ignore(numeric_limits<streamsize>::max(),'\n');
Ho letto che cin.ignore(n, d) legge (senza memorizzarli da nessuna parte) al
massimo n caratteri e se raggiunge il delimitatore d lo elimina anche e che
una chiamata come cin.getline() equivale a buttar via il primo carattere...
ma il tutto non e' molto chiaro anche perche' il seguente sorgente:
#include <iostream>
int main() {
 char s[20];
 std::cin >> s;
 cin.ignore();
 std::cout << s << std::endl;
 return 0;
}
stampa quello che immetto, senza togliere nulla... potresti farmi un esempio
tu? Anche qualcuno con il getline parametrizzato se puoi.
Inoltre ho provato:
#include <iostream>
int main() {
 cin.ignore(7);
 std::cout << "FINE"<< std::endl;
 return 0;
}
Il quale se immetto fino a 5 caratteri per riga, premendo invio posso
inserirne ancora. Se ne metto 6 premendo invio il programma termina. Se
inserisco un carattere per ogni riga, al 4° premendo invio il programma
termina. Diversamente se ne inserisco 2 alla volta... l'esempio seguente
spieghera' tutto meglio credo:
Es.:
12345 [INVIO]
6     [INVIO]
FINE
**************
123456 [INVIO]
FINE
**************
1 [INVIO]
2 [INVIO]
3 [INVIO]
4 [INVIO]
FINE
**************
12 [INVIO]
34 [INVIO]
5 [INVIO]
FINE
Ma che regole segue???
Grazie

 e poi max() che fa?
E' un metodo che restituisce la lunghezza massima di un campo numerico
all'interno di uno stream. Quindi il metodo ignore() ignora (appunto) i
prossimi caratteri nello stream fino al '\n' o al piů fino alla
lunghezza massima.


 e trattiamo il problema sulle FAQ. Che ne pensi/pensate?
Ok. Vediamo se va bene una cosa del genere:
Q) Come mai il metodo cin.getline() a volte sembra non essere eseguito?
A) Ad esempio, lanciando un programma del genere
   #include <iostream>
   int main()
   {
       int Numero;
       std::cout << "Inserisci il numero: ";
       std::cin >> Numero;
       std::cout << Numero << '\n';
       char Stringa[ 80 ];
       std::cout << "Inserisci la stringa: ";
       std::cin.getline(Stringa, 80);
       std::cout << Stringa << '\n';
       return 0;
   }
   vediamo che l'esecuzione si arresta alla richiesta di inserimento del
   numero ma non a quella di inserimento della stringa. Il motivo č che
   nello stream, dopo la lettura del numero, resta un '\n' che viene
   considerato dalla successiva lettura come la fine della stringa
   acquisita (che quindi risulta nulla). Per ovviare basta inserire
   std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
   prima della lettura della stringa (e #include <limits> all'inizio).
   Questa istruzione fa sě che vengano ignorati tutti i caratteri
   successivi presenti nello stream fino al '\n', se presente, o al piů
   fino alla lunghezza massima consentita per un campo numerico.


 }
Ho fatto un po di prove... ma rimane un dubbio in merito al precedente
codice:
Se inserisco come input una stringa, non appena digito il 7° carattere il
programma si interrompe senza nemmeno premere invio. Ma questo solo se lo
eseguo nella finestra dell'editor (uso SciTE). Se invece eseguo il programma
sul prompt DOS posso inserire una stringa lunga anche piu di 7 caratteri ma
il programma non termina...
Sapete spiegarmi quale dei 2 e' il comportamento giusto? A me sembra il
primo, ma prompt sembra piu attendibile...
Grazie

 Ma che regole segue???
Forse non consideravi i '\n'.


 primo, ma prompt sembra piu attendibile...
A me sembra corretto il comportamento del prompt ma forse lo dico solo
perché ho sempre visto quello.


 Forse non consideravi i '\n'.
Gią, non li contavo, pensavo non ne tenesse conto nel conteggio.

 [SKIP]
Ciao,
Ho letto molto velocemente, però mi sembra che il lavoro sia ben fatto.
fabiomdf


 Ho letto molto velocemente, però mi sembra che il lavoro sia ben fatto.
Ok, ho aggiornato la FAQ (domanda numero 20):
http://www.emagsoftware.it/faqcpp.txt


 Ok, ho aggiornato la FAQ (domanda numero 20):
eh beh... nemmeno una menzioncina per me che ho posto il problema per 
l'ennesima volta, (e fornito anche la soluzione !!) :_DDDDD ??
No vabbč, nn voglio fare lo sborone...
Piů che altro ringrazio il NG e in particolare Enrico Maria e Noixe, che si 
sono
cosě interessati alla questione...
byez
Aleander