Newsgroup: it.comp.lang.c
Titolo: Stringa come array...

Salve a tutti ,
ho questo piccolo problema:
come posso estrarre i valori da una striga così definita ?
char *stringa;
ad esempio voglio prelevare il 2° carattere .... come faccio ?
scrivere  app =  stringa[2];   non è corretto il compilatore mi da un
segmentation fault.
se scrivo app = A+2;   mi restituisce tutta la strnga a partire dal 2°
carattere ... ma a me serve il singolo s° carattere...
potete aiutarmi ?
grazie
Snakeeyes

char *stringa;
Hai allocato lo spazio per il puntatore ?
--
Andrea Laforgia (ICQ 87230455)
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

 wrote in message
news:98g3g7$m13$1...@lacerta.tiscalinet.it...


char carattere = *(stringa + 1);
La maggiore efficienza di quest'ultima soluzione, rispetto alla prima,
e' davvero discutibile.  In generale, non e' vero che usare i
puntatori porti a una maggiore velocita' che usare gli array.


 wrote in message
news:q66natok7ig1dvc73...@4ax.com...


d'esperienza troverai codice che impiega l'indicizzazione.
Non e' sempre cosi'.
Non so che programmi, scritti da professionisti d'esperienza, hai
letto, ma e' una cosa ben nota che puo' essere vero l'esatto
contrario.  Tutto dipende da quale sistema si utilizza.
Tratto dalle FAQ di comp.lang.c :
Question 20.14
Are pointers really faster than arrays? 
--------------------------------------------------------------------------------
It is ``usually'' faster to march through large arrays with pointers
rather than array subscripts, but for some processors the reverse is
true.


 wrote in message
news:h07natciln0oarv9s...@4ax.com...


piu efficiente.
No, non lo e' affatto.  
Evidentemente hai letto poco bene : e' una questione dipendente
dall'implementazione.
p.s.: ti prego di rispettare le regole di quoting.


 wrote in message
news:n79natotsk5vtqsbn...@4ax.com...


Ho trovato l'errore, il puntatore non puntava correttamente,  grazie per
l'aiuto ....
ma ora insorge un'altro problema ....
ho :
char *stringa, app1;
stringa = "abcdefg";     // riempio la stringa con delle lettere
app1 = stringa[0];     // prendo l'elemento in 0
stringa[5] = app1;     // qui mi da un bel segmentation fault !!!
come posso risolvere il problema ??  Dovrei riuscire a spostare l'elemento
in stringa[0]
alla fine della stringa e poi shiftare tutti gli altri verso SX...
partendo da  "abcde" dovrei ottenere "bcdea"  ....
grazie
Snakeeyes

sono qui per aiutare se mi è possibile, il resto non mi interessa.
No, è buona educazione. Per favore, quando rispondi ad un messaggio riporta
solo la parte che interessa, e solo il minimo indispensabile per far capire
agli altri a cosa stai rispondendo.
Ok, ora non ti arrabbiare con me perché te l'ho detto, non dire che questo
post è off-topic, non dire che non c'entra nulla, non dire che non mi sono
intromesso in una discussione, per favore.
Lanugo

char carattere = *(stringa + 1);
Posso dire la mia?
Dalle prove che ho fatto, nel caso di array monodimensionali è del tutto
indifferente (penso che stringa[1] venga convertito esattamente nello stesso
codice di *(stringa+1), addirittura), per array pluridimensionali cambia
qualcosetta, credo che sia perché il sistema deve calcolarsi l'offset
"monodimensionale" di un elemento in un array pluridimensionale. La
differenza è minima, almeno, col mio amd k6 sotto windows e sotto linux.
Lanugo

Come ho detto, il resto non mi interessa.
Bob Rock

d'esperienza troverai codice che impiega l'indicizzazione.
Certamente non in cose come char s=*(stringa+1).
E' vero che ci sono casi in cui l'aritmetica dei puntatori
e' preferibile a indicizzazione... poni ad esempio:
   typedef struct MYSTRUCT_TAG
   {
     int x,y,z,t,w;
   } MyStruct;
   /* 
   ** Azzera il campo "w" da un array
   ** di "num" elementi di tipo "MyStruct"
   */
   void ZapW(MyStruct *v,int num)
   {
     int i;
     for (i=0; i<num; i++)
     {
       v[i].w=0;
     }
   }
   /* 
   ** Idem ma probabilmente piu' efficiente
   */
   void ZapW2(MyStruct *v,int num)
   {
     MyStruct *i,*e;
     for (i=v,e=v+num; i!=e; i++)
     {
       i->w=0;
     }
   }
Molti compilatori riusciranno a generare codice piu'
efficiente per ZapW2 che per ZapW (anche se in realta'
ottimizzatori abbastanza furbi potrebbero generare
cose equivalenti).
Ci sono pero' anche casi in cui l'uso di puntatori potrebbe
portare a codice *meno* efficiente dell'uso di indicizzazioni.
Questo in particolare nel caso che la CPU preveda l'accesso
indicizzato con scalatura (questo e' il caso ad esempio del
386) e l'elemento di array abbia una dimensione compatibile
con le scale previste dalla CPU.
L'uso di indicizzazioni invece di puntatori potrebbe in in
questo caso portare ad un risparmio di registri
nell'elaborazione parallela (ovvero usando lo stesso indice)
di diversi array.
Esempi come quello che hai fatto tu sono semplicemente
meno leggibili.
Il discorso che fai vale infatti esclusivamente per
l'accesso a diversi elementi in sequenza (l'uso
dell'indicizzazione potrebbe richiedere costose
moltiplicazioni mentre l'uso di puntatori semplici
addizioni). Per un singolo accesso e' un ragionamento
che non ha alcun senso.
Forse vale la pena ricordare che la regola numero *uno*
per ottimizzare e' misurare e analizzare per capire dove
viene perso tempo/spazio. Se lo avessi fatto mai ti
sarebbe venuto in mente di scrivere brutture come
"*(string+1)"
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

alla fine della stringa e poi shiftare tutti gli altri verso SX...
Quello che stai tentando di fare è illegale. Quando tu scrivi
string = "abcdefg";
fai puntare stringa ad una zona di memoria a sola lettura, il cui contenuto
è costante e non può essere modificato, e quando tenti di farlo, per
l'appunto, crasha tutto (il fatto che crashi non è una cosa prevista dallo
standard, che dice che il comportamento è indefinito).
Prova con
char stringa[5] = "abcdefg";
e tutto dovrebbe funzionare.
Lanugo

>Come ho detto, il resto non mi interessa.
Interessa al resto del mondo. Ci sono regole che si devono rispettare su
usenet. Una di queste č quotare.
Fine di questa semidiscussione. Capirai anche tu che se nessuno quotasse
tutti i gruppi del mondo diventerebbero un grosso casino, ed anche se a te
il resto non interessa, a molti altri sě.
Lanugo

tutti gli altri verso SX...
Forse ti conviene salvare il primo carattere in una variabile,
quindi spostare gli altri indietro di un passo e infine mettere
il carattere che avevi salvato nell'ultima posizione.


Regole? Di quali regole stiamo parlando? Credi davvero che chi viene qui per
cercare aiuto si attenga o anche soltanto conosca queste regole? La risposta
č semplice: no. E tuttavia riescono a farsi capire, e riescono ad essere
aiutati. Questo e altri newsgroup sopravvivono e prosperano tranquillamente
senza che nessuno pretenda di imbrigliare gli altri in regole che non hanno
contribuito a scrivere.
Bob Rock
"Lanugo of the wandering souls" <lan...@SCEMOCHISPAMMAflashmail.com> wrote
in message news:lZOq6.124416$wA6.5...@e420r-sjo3.usenetserver.com...


E' la prima volta che posto in questo NG, devo dire
che funziona davvero bene !
Siete stati molto gentili e precisi .
Grazie
Snakeeyes

 contribuito a scrivere.
Allora  tu non  rispetti il  Codice Penale  italiano, dato  che non  hai
contribuito a scriverlo? O, se vai negli  Stati Uniti, fai lo stesso con
il  loro Codice  Stradale? In  Inghilterra  andresti contromano  perche'
tanto e` lo stesso?
Non essere ridicolo.
f/up dove opportuno, e  .
Ciao,
 Emmanuele
-- 
Emmanuele Bassi         |  Linux: [ 
http://digilander.iol.it/ebassi/linux/
 ]
                        |   SLRN: [ 
http://digilander.iol.it/ebassi/slrn/
  ]
emmanue...@iol.it
  |   SETI: [ 
http://digilander.iol.it/ebassi/seti/
  ]
  GnuPG Key Fingerprint: 9747 635E B95A B0B3 4370 1CAA CAF7 512B 945C A44C

 
emmanue...@iol.it
  |   SETI: [


Quanti ipocrisia c'è in giro. E quanti sceriffi.
Non sono né sceriffo né ipocrita. Se non ti va di rispettare le regole
peccato, a me più di tanto non interessa, tanto più che non sono regole
coercitive in senso stretto. Però, siccome non le segui, non lamentarti se
qualcuno ogni tanto te lo fa notare.
Lanugo

char carattere = *(stringa + 1);
Guarda che il codice assembler generato con un compilatore C/C++
appena decente (almeno su piattaforma x86 con S.O. a 32 bit) e' lo
stesso. Non c'e' nessun motivo per preferire una soluzione rispetto
l'altra, se non che personalmente trovo la prima piu' leggibile.
Mi sembra anzi che lo standard deprechi soluzioni del tipo
char* stringa = "mia stringa";
a favore di quelle del tipo
char stringa[] = "mia stringa";
-- 
Tieni per te il Papero se vuoi la mia email
Sito Papero -> 
http://utenti.tripod.it/papero

char stringa[] = "mia stringa";
Sono 2 cose TOTALMENTE differenti.
char *stringa = "mia stringa" crea una stringa da cui puoi solo leggere;
char stringa[] = "mia stringa" crea una stringa su cui puoi anche scrivere.
Lanugo

char stringa[] = "mia stringa" crea una stringa su cui puoi anche scrivere.
E' vero, pero per le strinche costanti preferisco la notazione
const char stringa[] =  "mia stringa";
E tecnicamente sarebbe piu' corretto scrivere
const char *stringa = "mia stringa"; 


const char *stringa = "mia stringa";
Hai perfettamente ragione.
char *stringa = "mia stringa";
non rende palese che la stringa non è modificabile, e credo che se non si
faccia attenzione sia parecchio facile sbagliare qualcosa.
Lanugo