Newsgroup: it.comp.lang.c++
Titolo: Odio i puntari!

Purtroppo sono costretto ad usare gli array. potresti comunque dirmi cosa
effettua l'istruzione strstr?
Grazie!

 effettua l'istruzione strstr?
const char* strstr(const char* pagliaio, const char* ago)
effettua esattamente il compito da te specificato: cerca ago
in pagliaio, torna il primo indirizzo entro pagliaio ove inizia
la 'stringa' specificata in ago, torna 0 se non trovata.
Alex

invece simulare le stringhe con gli array di caratteri, ti pare...?
Anche il C++ simula le stringhe attraverso un vettori di char.
Nella classe string c'e' proprio un char*
Se poi per qualche motivo uno non ha bisogno di tutte le funzionalita'
di string, IMHO farebbe meglio a usare un array di char. (e' anche piu' 
veloce)
Ciao, David

significativo.
Di sicuro non lo e' se dovessi riscrivermi le funzioni gia' presenti
nella classe suddetta.
David

David
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

    }
Ora, non per fare polemica, ho capito le tue argomentazioni e mi sembrano
giuste, ma ls funzione prossimo2 si potrebbe migliorare un pochetto.
Mettiamo curlen insieme alla dichiarazione di char lafintastringa[N];
inizializzandolo a 0. Poi eliminiamo la chiamata a strlen e scriviamo
lafintastringa[curlen++]=prox
lafintastringa[curlen]=0
Converrai che questa sono le stesse operazioni che deve fare string, ma 
risparmi la chiamata ad operator+ (vabbe sempre meglio di niente).
Ciao David

 risparmi la chiamata ad operator+ (vabbe sempre meglio di niente).
Aggiungendo sufficiente complessita` ai tuoi dati ausiliari, puoi arrivare
a reimplementare QUASI altrettanto bene std::string (QUASI perche`
per quella built-in il compilatore puo` essere in grado di effettuare piu`
ottimizzazioni, a seconda dei casi, essendo la semantica vincolata e nota
al compilatore stesso).
In questo caso, il "risparmio" che ottieni NON e` "meglio di niente": e`
ESATTAMENTE niente, perche` l'operator+ e` inline e quindi quella
che "sembra" una chiamata ad esso in realta` si espande in-linea.
Viceversa, la prossimo3 con le tue drastiche modifiche strutturali
(che rendono responsabile il chiamante di mantenere anche un
intero da passarsi per-riferimento -- dettaglio che trascuravi) e`
ancora molto piu` lenta: infatti, essa scrive DUE volte in memoria
per ogni carattere che arriva (poiche` deve mantenere lo zero di
terminazione).  std::string non ha nessun bisogno di tenere uno
zero di terminazione (poiche` mantiene, SENZA carico di sviluppo
per il chiamante!!!, il valore ausiliario lunghezza-corrente) e quindi
non ha di questi problemi.
E adesso veniamo al caso comune, in cui NON SAI con certezza
assoluta quanti caratteri arriveranno.
Se usi std::string: ZERO costo -- la funzione gia` scritta va
BENISSIMO.
Se usi array -- auguri.  Devi nuovamente riprogettare da capo
la funzione e TUTTI i suoi chiamanti.
Tutti questi casi sono BEN LUNGI dall'usare l'"INTERA" potenza
di std::string -- siamo a pochi percento.
E nonostante questo, std::string si dimostra gia`, non solo
MOLTO piu` comoda da usare, ma anche piu` performante.
Consiglio del programmatore C++ a tutti gli altri programmatori
C++:
Lasciate perdere gli array.  La probabilita` che vi troviate davvero
in una situazione in cui un array e` la cosa piu` appropriata (e
std::string, std::vector, ecc, non adatti) e` INFINITESIMA, e in
ogni caso MOLTO, MOLTO inferiore a quella che, commettendo
un errore di valutazione in fase progetto, CREDIATE che sia meglio
usare un array in casi in cui non e` cosi`.
Chi facesse voto a San Bjoerne di non usare MAI gli array non
programmerebbe in "C++ ideale e perfetto", ma vi sarebbe
MOLTO piu` vicino del 99.7% dei programmatori C++ che ho
avuto il caso di osservare da vicino...!-)
Alex

Ciao David
