Newsgroup: it.comp.lang.c
Titolo: Ricerca carattere in stringa

Salve a tutti.
Ho un problema relativo alla ricerca di un carattere in una stringa. Se il
carattere fosse uno solo, mi basterebbe usare la strchr(). Tuttavia io devo
scandire la mia stringa alla ricerca del primo di una serie di caratteri. Mi
spiego con un esempio:
la stringa è del tipo: $1$2@$3$4.
Io devo cercare tutte le occorrenze dei caratteri $ e @. Considerando un
puntatore all'indirizzo del primo carattere, dopo il primo giro vorrei che
questo puntatore valesse 1$2@$3$4; al secondo giro vorrei avere 2@$3$4; al
terzo $3$4; al quarto 3$4; infine 4.
Qualcuno conosce un modo per ottenere un risultato del genere (una strchr()
che controlli il raggiungimento di uno di un insieme di caratteri, anziché
un unico carattere)?
Grazie a chi mi vorrà rispondere!
F.


Vediamo un po': codice buttato cosi' senza testare e sempre troppo 
pensarci, sei avvertito:
char *strchrs(const char *s, const char *cs)
{
   char* res, res2;
   if(*cs == '\0')
     return NULL;
   res = strchr(s, *cs);
   while(*cs++)
     if( (res2 = strchr(s, cs)) < res )
       res = res2;
   return res;
}
Es: nel tuo caso avresti usato delle chiamate a strchrs(string, "$@");
PS: qualcuno sa perche' la strchr prende un _int_ come secondo 
argomento, e non un banale char?
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Linux registered user 299762 @ Linux registered machine 213003

 Grazie a chi mi vorrà rispondere!
strlen("Grazie a chi mi vorrà rispondere!") > strlen("Grazie.")
E avresti fatto una figura migliore nei confronti di chi ti ha letto
pur non sapendo risponderti.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG


Crepi l'avarizia, grazie a chi mi ha letto e grazie 1000 a chi mi ha
risposto! ;-)
F.

 argomento, e non un banale char?
Lungimiranza? In fondo anche considerando gli alfabeti a caratteri
latini 256 caratteri sono ampiamente insufficienti.


 latini 256 caratteri sono ampiamente insufficienti.
Beh, pero' poi va a cercare il carattere in un array di char, quindi se 
ne fa cmq poco di un int...
E poi, per la faccenda dei caratteri, esiste il wchar_t apposta...


 E poi, per la faccenda dei caratteri, esiste il wchar_t apposta...
Poi le cose cambiano e l'evoluzione di qualcosa non sempre segue la
via che qualcuno aveva previsto.


 al singolo byte, ...
.. e questa e' una palese fesseria, visto che oggi si fa lo stesso.
Quello che volevo dire e' che all'epoca si usava il char* anche come
puntatore generico.
Sorry.


 argomento, e non un banale char?
Faccio notare che l'interrogativo si può estendere a qualsiasi altra
funzione della StdLib che prenda un codice carattere come argomento o che
ritorni un codice carattere:
    int getchar(void)
    int putchar(int c);
    char *strchr(const char *s, int c);
    //... ecc.
È facile intuire perché il valore di RITORNO debba essere un int: perché
queste funzioni, oltre a un valido codice carattere, devono essere in grado
di ritornare EOF, un valore di tipo int che NON neccessariamente è
rappresentabile in un char.
Ma perché fare int anche gli ARGOMENTI delle funzioni? Non ha molto senso
scrivere codice di questo tipo:
   puchar(EOF);
   s = strchr("abcd", EOF);
Ma si consideri questo codice:
   int c;
   while ((c = getchar()) != EOF)
   {
      if (strchr("aeiou", c) != NULL)
         putchar('*');
      putchar(c);
   }
Se l'argomento di strchr() e di putchar() fosse di tipo char, bisognerebbe
mettere un cast ogni volta che si passa la variabile c a una delle due
funzioni!
A me dunque non pare strano che strchr() o putchar() abbiano il tipo int: se
così non fosse, i compilatori ci riempirebbero di warning inutili.
Piuttosto mi pare assurdo che questa convenzione non sia stata mantenuta
nelle versioni wide-char delle stesse funzioni:
   wint_t getwchar(void);
   wint_t putwchar(wchar_t c)
   wchar_t *wcschr(const wchar_t *s, wchar_t c);
A essere pignoli, la versione wide-char del codice sopra richiederebbe un
cast ogni volta che si passa un carattere a una libreria:
   wint_t c;
   while ((c = getwchar()) != WEOF)
   {
      if (wcschr(L"aeiou", (wchar_t)c) != NULL)
         putwchar(L'*');
      putwchar((wchar_t)c);
   }
In realtà, quei cast non ce li mette mai nessuno perché "tanto si sa" che
"di solito" i tipi wchar_t e wint_t sono uguali. Ma proprio perché "tanto si
sa" che i due tipi sono uguali nella maggior parte delle implementazioni,
che costava, a lor signori gli standardizzatori del C99, usare il tipo
logicamente giusto?
--
Cingar
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/