Newsgroup: it.comp.lang.c++
Titolo: problemi con stringhe

Salve
Ho un problema con le stringhe.
Vorrei inserire delle stringhe in un array di stringhe ma non so come fare.
Ho provato questa soluzione ma non funziona. Chi puo' aiutarmi?
Grazie!
#include <stdlib.h>
#include <ctype.h>
void inserisci(char *str);
int main()
{
      char *string[3];
      for (int i=0; i<3; i++)
          cin.getline(string[i], 20);
      for (int a=0; a<3; a++)
          cout<< string[a]<< endl;
      system("PAUSE");
      return 0;
}
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (
http://www.grisoft.com
).
Version: 6.0.303 / Virus Database: 164 - Release Date: 24/11/2001

           cin.getline(string[i], 20);
forse dovresti provare a svuotare il flusso di input prima di fare il 
getline.
prova ad usare questo codice:
    	char ch;
       for (int i=0; i<3; i++) { cin >> ch; cin.getline(string[i], 20); }


 getline.
oppure, dato che siamo nel c++, perchè nn usare il tipo string!
scrivi:
#include <string>
#include <iostream>
using namespace std;
int main()
{
 string pippo[3];    //ecco il tuo array di stringhe...
 int i;
 for(i = 0; i < 3; i++)
  cin >> pippo[i];
 for(i = 0; i < 3; i++)
  cout << pippo[i] << endl;
}

 oppure, dato che siamo nel c++, perchè nn usare il tipo string!
oppure, dato che si scrive in italiano, perchè nOn usare la O!
-- 
Luc.

 ha scritto nel messaggio
news:lHO78.22408$nI1.6...@twister1.libero.it...

e per inserire anche gli spazi nella stringa?
Grazie!


 e per inserire anche gli spazi nella stringa?
Usa getline come facevi tu all'inizio:
#include <string>
#include <iostream>
int main()
{
    std::string pippo[3];  //ecco il tuo array di stringhe... int i;
    for(int i = 0; i < 3; ++i)
        std::getline(std::cin, pippo[i]);
    for(int i = 0; i < 3; ++i)
        std::cout << pippo[i] << std::endl;
}
p.s. impara a quotare meglio:
http://www.uwasa.fi/~ts/http/quote.html
--
Gerolamo

[snip (codice)]
non ho capito perchè mi hai
levato "using namespace std"
e lo hai infilato da tutte le parti...
non è + comodo scriverlo una
volta sola?
--
Licantrop0 / HackZ ExtremE Crew from 2001

ancora una cosa...
come me lo spieghi questo comportamento:
---------------Inizio Output----------------
[0] zero
uno
[1] due
[2] tre
[0] zero
[1] uno
[2] due
Press any key to continue
---------------Fine Output----------------
Da un codice del genere:
---------------Inizio Codice----------------
#include <string>
#include <iostream>
using namespace std;
int main()
{
    string pippo[3];  //ecco il tuo array di stringhe...
 int i;
    for(i = 0; i < 3; ++i)
 {
  cout << "[" << i << "] ";
        getline(cin, pippo[i]);
 }
 cout << endl;
    for(i = 0; i < 3; ++i)
        cout << "[" << i << "] " << pippo[i] << endl;
}
---------------Fine Codice----------------


 volta sola?
Più comodo di sicuro.
Considera però questo fatto:
se tutte le volte che devo usare qualcosa interno a un namespace N
ci metto un "using namespace N" quale è il vantaggio di avere i
namespaces?
Con quella using directive di fatto porto tutto il namespace nel
namespace globale, e questo potrebbe causare omonimie.
Comunque per un esempio giocattolo come quello delle stringhe
va bene anche metterci lo "using namespace std".
Io preferisco in generale non metterlo, per non prendere cattive abitudini.
Al limite, comunque, meglio un "using std::cout" .
Ciao
--
Gerolamo

 [2] tre
Il mio compilatore (borland 5.5.1) non mi da questo problema.
Cosě ad occhio direi di provare a mettere un
cout.flush();
dopo la riga
cout << "[" << i << "] ";
perň č strano... che compilatore usi?
--
Gerolamo

 namespace globale, e questo potrebbe causare omonimie.
Sì, ma è comunque limitato ad una sola T.U., e il compilatore dovrebbe
pure avvertirti. Altrimenti nei namespace ci vedo solo scomodità!

 perň č strano... che compilatore usi?
Il visual c++ 6...
io l'ho messo il flush... ma nn so cosa fa... e cmq mi da lo
stesso probz... sembra che il getline(cin, pippo[i])
dia problemi perchč se metto cin >> pippo[i]; va...


Al limite, comunque, meglio un "using std::cout" .
Nel codice professionale é altamente sconsigliato, specie se stiamo
progettando una libreria che dovrà essere usata da altri programmatori
c++, che sicuramente non gradirebbero la cosa.
Il Ghenio
---------
// TODO: Place your ass here

         std::getline(std::cin, pippo[i]);
nota che questa non e` la stessa cosa che faceva all'inizio: prima 
richiamava std::cin.getline, ovvero una funzione membro di std::istream, 
mentre ora richiama std::getline, ovvero una funzione non membro che 
prende come primo argomento un istream.
Per la precisione :-)
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.79, higher than 92% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 compaia in un file .cpp e non in un header.
Il fatto è che con "using namespace N" potresti rendere usabili
direttamente anche funzioni/oggetti che non sai di aver reso usabile
e quindi potresti aver creato inavvertitamente delle ambiguità.
A quel punto forse è meglio un elenco di "using N::qualcosa"
così hai più sotto controllo la situazione.
almeno credo...
--
Gerolamo

 c++, che sicuramente non gradirebbero la cosa.
Parlavo di file .cpp non di header né, soprattutto, di librerie, nei quali
casi sono perfettamente d'accordo con te
--
Gerolamo

 dia problemi perchè se metto cin >> pippo[i]; va...
A questo punto non so aiutarti... mi spiace.
Il Visual C++ 6 è vecchio e pre-standard, può essere che abbia
questi problemi.
--
Gerolamo

 Per la precisione :-)
Meglio essere troppo precisi che approssimativi, quando si programma :-))
--
Gerolamo

Hai ragione. (non vi fate scappare nulla, eh??? :-)
Quando si parla di un linguaggio come il c++ la precisione é tutto.


 compaia in un file .cpp e non in un header. 
c'e` da dire che la qualificazione esplicita dei nomi in un namespace e` 
anche un modo per autodocumentare (parzialmente) il codice; ad esempio 
un programmatore non particolarmente esperto potrebbe non conoscere 
qualche algoritmo standard; pero` se legge:
        int tot = std::accumulate(v.begin(), v.end(), 0);
sa immediatamente che accumulate fa parte della libreria standard, senza 
perdersi a cercarla in decine di header specifici dell'applicazione.
E` ovvio che con il passare degli anni saranno sempre meno le persone a 
non conoscere decentemente la libreria standard, ma per ora...


 non conoscere decentemente la libreria standard, ma per ora...
io vedo le cose solo dall'interno del mio luogo di lavoro, ma non
sarei ottimista come lo sei tu..

 qualcosa di utile ;-)
ROTFL :-)
