"Giusto per" (gran bella cosa le ferie!), m'è venuto il ghiribizzo di provare a fare una specie di "strtok() dei poveri" procedendo di testa mia.
Dal momento che mi ha sempre sconfifferato poco il fatto che la strtok() vera abbia questa specie di "persistenza", mi son detto: "la mia NON deve memorizzare alcun indice tra le chiamate". In più, giocherellando, mi sono accorto che la strtok() vera non ammette l'esistenza di elementi "vuoti", ovvero che se ci sono due terminatori adiacenti, l'elemento "vuoto" che ci si aspetterebbe di trovarci in mezzo viene omesso, saltato, ignorato... a me sembra un comportamento un po' strano.
Edit:: in più, ancora, strtok() modifica la stringa originale (infatti le si passa un char* e non un const char*) inzuppandola di terminatori.
Dunque, ho messo insieme Tuchinen(). Un particolare importante è che il nome della funzione si legge "Tuchinén", parola che significa "pezzettino". Mi sarebbe piaciuto anche chiamarla "strok!", come quando uno si becca una fregatura e... "STROK!", però l'assonanza sarebbe stata eccessiva e mi sarebbero magari state contestate questioni di copyright.
Donca, ciapa's tuchinén e lasla bùi, nuiùs d'in nuiùs!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TIPO_ESEMPIO 1 // tra 0 e 6, per provare 7 situazioni diverse
#if TIPO_ESEMPIO == 0
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen|quarto tuchen";
#elif TIPO_ESEMPIO == 1
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen";
#elif TIPO_ESEMPIO == 2
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen|";
#elif TIPO_ESEMPIO == 3
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 4
char gStrEsempio[] = "|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 5
char gStrEsempio[] = "";
#elif TIPO_ESEMPIO == 6
char *gStrEsempio = NULL;
#endif // switch TIPO_ESEMPIO
/*==============================================================================
Analizza la stringa C contenuta nell'array di caratteri che parte da "inizio" in
cerca di uno qualsiasi tra i caratteri contenuti nella stringa C contenuta
nell'array "sep". Appena trova la prima occorrenza di uno di quei caratteri ne
memorizza il puntatore in "fine" e restituisce la quantita' dei caratteri
compresi tra inizio (compreso) e fine (escluso).
Se viene raggiunta la fine della stringa C contenuta nell'array "inizio" senza
che sia stato trovato alcuno dei caratteri ricercati, in "fine" viene inserito
un puntatore NULL.
Se "inizio" e' un puntatore NULL, anche "fine" sara' un puntatore NULL e la
funzione restituira' -1 (chiaramente una lunghezza non valida per qualsivoglia
stringa).
Se "inizio" punta a una stringa vuota, si considera comunque che contenga un
elemento, perche' anche una stringa costituita dal solo terminatore e' comunque
un elemento valido (una stringa lunga zero caratteri).
==============================================================================*/
int Tuchinen( const char *inizio, char **fine, const char *sep ) {
if( inizio )
return (*fine=strpbrk(inizio,sep)) ? *fine-inizio : strlen(inizio);
else { *fine = NULL; return -1; }
}
/*==============================================================================
Un programmino da intendere come esempio e come test.
Cerca gli elementi contenuti nella stringa gStrEsempio (definita in piu'
versioni in testa alla pagina) usando come separatore il solo carattere "|"
(puo' essere interessante provare a usare due separatori contemporaneamente, ad
esempio passando "| " o qualsiasi altra cosa).
==============================================================================*/
int main() {
char *inizio = NULL; // puntatore ausiliario
char *fine = NULL; // puntatore ausiliario
int totToc = 0; // la quantita' degli elementi rilevati
int lToc = 0; // la lunghezza dell'elemento corrente
char aux = '"Giusto per" (gran bella cosa le ferie!), m'è venuto il ghiribizzo di provare a fare una specie di "strtok() dei poveri" procedendo di testa mia.
Dal momento che mi ha sempre sconfifferato poco il fatto che la strtok() vera abbia questa specie di "persistenza", mi son detto: "la mia NON deve memorizzare alcun indice tra le chiamate". In più, giocherellando, mi sono accorto che la strtok() vera non ammette l'esistenza di elementi "vuoti", ovvero che se ci sono due terminatori adiacenti, l'elemento "vuoto" che ci si aspetterebbe di trovarci in mezzo viene omesso, saltato, ignorato... a me sembra un comportamento un po' strano.
Edit:: in più, ancora, strtok() modifica la stringa originale (infatti le si passa un char* e non un const char*) inzuppandola di terminatori.
Dunque, ho messo insieme Tuchinen(). Un particolare importante è che il nome della funzione si legge "Tuchinén", parola che significa "pezzettino". Mi sarebbe piaciuto anche chiamarla "strok!", come quando uno si becca una fregatura e... "STROK!", però l'assonanza sarebbe stata eccessiva e mi sarebbero magari state contestate questioni di copyright.
Donca, ciapa's tuchinén e lasla bùi, nuiùs d'in nuiùs!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TIPO_ESEMPIO 1 // tra 0 e 6, per provare 7 situazioni diverse
#if TIPO_ESEMPIO == 0
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen|quarto tuchen";
#elif TIPO_ESEMPIO == 1
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen";
#elif TIPO_ESEMPIO == 2
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen|";
#elif TIPO_ESEMPIO == 3
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 4
char gStrEsempio[] = "|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 5
char gStrEsempio[] = "";
#elif TIPO_ESEMPIO == 6
char *gStrEsempio = NULL;
#endif // switch TIPO_ESEMPIO
/*==============================================================================
Analizza la stringa C contenuta nell'array di caratteri che parte da "inizio" in
cerca di uno qualsiasi tra i caratteri contenuti nella stringa C contenuta
nell'array "sep". Appena trova la prima occorrenza di uno di quei caratteri ne
memorizza il puntatore in "fine" e restituisce la quantita' dei caratteri
compresi tra inizio (compreso) e fine (escluso).
Se viene raggiunta la fine della stringa C contenuta nell'array "inizio" senza
che sia stato trovato alcuno dei caratteri ricercati, in "fine" viene inserito
un puntatore NULL.
Se "inizio" e' un puntatore NULL, anche "fine" sara' un puntatore NULL e la
funzione restituira' -1 (chiaramente una lunghezza non valida per qualsivoglia
stringa).
Se "inizio" punta a una stringa vuota, si considera comunque che contenga un
elemento, perche' anche una stringa costituita dal solo terminatore e' comunque
un elemento valido (una stringa lunga zero caratteri).
==============================================================================*/
int Tuchinen( const char *inizio, char **fine, const char *sep ) {
if( inizio )
return (*fine=strpbrk(inizio,sep)) ? *fine-inizio : strlen(inizio);
else { *fine = NULL; return -1; }
}
/*==============================================================================
Un programmino da intendere come esempio e come test.
Cerca gli elementi contenuti nella stringa gStrEsempio (definita in piu'
versioni in testa alla pagina) usando come separatore il solo carattere "|"
(puo' essere interessante provare a usare due separatori contemporaneamente, ad
esempio passando "| " o qualsiasi altra cosa).
==============================================================================*/
int main() {
char *inizio = NULL; // puntatore ausiliario
char *fine = NULL; // puntatore ausiliario
int totToc = 0; // la quantita' degli elementi rilevati
int lToc = 0; // la lunghezza dell'elemento corrente
char aux = '{parsed_message}'; // carattere ausiliario
inizio = gStrEsempio; // da dove cominciare?
do {
// la chiamata alla funzione da provare
lToc = Tuchinen( inizio, &fine, "|" );
if( lToc >= 0 ) { // se lToc fosse minore di zero, significherebbe
// che non e' stato trovato alcun elemento valido
// per poter stampare la stringa di lToc caratteri che parte da
// "inizio", occorre inserire TEMPORANEAMENTE un terminatore '{parsed_message}'
// alla posizione inizio+lToc
aux = *(inizio+lToc);
*(inizio+lToc) = '{parsed_message}';
// visualizza un po' di informazioni
printf( "%4d. \"%s\" (%d caratteri)\n", ++totToc, inizio, lToc );
// ripristina il carattere temporaneamente
// sostituito con il carattere terminatore '{parsed_message}'
*(inizio+lToc) = aux;
// il carattere puntato da "fine" e' un separatore;
// la nuova ricerca dovra' partire dal carattere successivo
inizio=fine+1; // per questo, "+1"
}
else {
// non sono ammessi puntatori NULL
printf( "Puntatore NULL, caprone!\n" );
}
} while( fine ); // se "fine" e' NULL vuol dire
// che si e' in fondo alla stringa
return 0;
}
P.S. Per la cronaca, se [i]tuchinén è un pezzettino, direi che dovrebbe essere ovvio che un tòc è un pezzo di medie dimensioni.'; // carattere ausiliario
inizio = gStrEsempio; // da dove cominciare?
do {
// la chiamata alla funzione da provare
lToc = Tuchinen( inizio, &fine, "|" );
if( lToc >= 0 ) { // se lToc fosse minore di zero, significherebbe
// che non e' stato trovato alcun elemento valido
// per poter stampare la stringa di lToc caratteri che parte da
// "inizio", occorre inserire TEMPORANEAMENTE un terminatore '"Giusto per" (gran bella cosa le ferie!), m'è venuto il ghiribizzo di provare a fare una specie di "strtok() dei poveri" procedendo di testa mia.
Dal momento che mi ha sempre sconfifferato poco il fatto che la strtok() vera abbia questa specie di "persistenza", mi son detto: "la mia NON deve memorizzare alcun indice tra le chiamate". In più, giocherellando, mi sono accorto che la strtok() vera non ammette l'esistenza di elementi "vuoti", ovvero che se ci sono due terminatori adiacenti, l'elemento "vuoto" che ci si aspetterebbe di trovarci in mezzo viene omesso, saltato, ignorato... a me sembra un comportamento un po' strano.
Edit:: in più, ancora, strtok() modifica la stringa originale (infatti le si passa un char* e non un const char*) inzuppandola di terminatori.
Dunque, ho messo insieme Tuchinen(). Un particolare importante è che il nome della funzione si legge "Tuchinén", parola che significa "pezzettino". Mi sarebbe piaciuto anche chiamarla "strok!", come quando uno si becca una fregatura e... "STROK!", però l'assonanza sarebbe stata eccessiva e mi sarebbero magari state contestate questioni di copyright.
Donca, ciapa's tuchinén e lasla bùi, nuiùs d'in nuiùs!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TIPO_ESEMPIO 1 // tra 0 e 6, per provare 7 situazioni diverse
#if TIPO_ESEMPIO == 0
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen|quarto tuchen";
#elif TIPO_ESEMPIO == 1
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen";
#elif TIPO_ESEMPIO == 2
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen|";
#elif TIPO_ESEMPIO == 3
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 4
char gStrEsempio[] = "|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 5
char gStrEsempio[] = "";
#elif TIPO_ESEMPIO == 6
char *gStrEsempio = NULL;
#endif // switch TIPO_ESEMPIO
/*==============================================================================
Analizza la stringa C contenuta nell'array di caratteri che parte da "inizio" in
cerca di uno qualsiasi tra i caratteri contenuti nella stringa C contenuta
nell'array "sep". Appena trova la prima occorrenza di uno di quei caratteri ne
memorizza il puntatore in "fine" e restituisce la quantita' dei caratteri
compresi tra inizio (compreso) e fine (escluso).
Se viene raggiunta la fine della stringa C contenuta nell'array "inizio" senza
che sia stato trovato alcuno dei caratteri ricercati, in "fine" viene inserito
un puntatore NULL.
Se "inizio" e' un puntatore NULL, anche "fine" sara' un puntatore NULL e la
funzione restituira' -1 (chiaramente una lunghezza non valida per qualsivoglia
stringa).
Se "inizio" punta a una stringa vuota, si considera comunque che contenga un
elemento, perche' anche una stringa costituita dal solo terminatore e' comunque
un elemento valido (una stringa lunga zero caratteri).
==============================================================================*/
int Tuchinen( const char *inizio, char **fine, const char *sep ) {
if( inizio )
return (*fine=strpbrk(inizio,sep)) ? *fine-inizio : strlen(inizio);
else { *fine = NULL; return -1; }
}
/*==============================================================================
Un programmino da intendere come esempio e come test.
Cerca gli elementi contenuti nella stringa gStrEsempio (definita in piu'
versioni in testa alla pagina) usando come separatore il solo carattere "|"
(puo' essere interessante provare a usare due separatori contemporaneamente, ad
esempio passando "| " o qualsiasi altra cosa).
==============================================================================*/
int main() {
char *inizio = NULL; // puntatore ausiliario
char *fine = NULL; // puntatore ausiliario
int totToc = 0; // la quantita' degli elementi rilevati
int lToc = 0; // la lunghezza dell'elemento corrente
char aux = '{parsed_message}'; // carattere ausiliario
inizio = gStrEsempio; // da dove cominciare?
do {
// la chiamata alla funzione da provare
lToc = Tuchinen( inizio, &fine, "|" );
if( lToc >= 0 ) { // se lToc fosse minore di zero, significherebbe
// che non e' stato trovato alcun elemento valido
// per poter stampare la stringa di lToc caratteri che parte da
// "inizio", occorre inserire TEMPORANEAMENTE un terminatore '{parsed_message}'
// alla posizione inizio+lToc
aux = *(inizio+lToc);
*(inizio+lToc) = '{parsed_message}';
// visualizza un po' di informazioni
printf( "%4d. \"%s\" (%d caratteri)\n", ++totToc, inizio, lToc );
// ripristina il carattere temporaneamente
// sostituito con il carattere terminatore '{parsed_message}'
*(inizio+lToc) = aux;
// il carattere puntato da "fine" e' un separatore;
// la nuova ricerca dovra' partire dal carattere successivo
inizio=fine+1; // per questo, "+1"
}
else {
// non sono ammessi puntatori NULL
printf( "Puntatore NULL, caprone!\n" );
}
} while( fine ); // se "fine" e' NULL vuol dire
// che si e' in fondo alla stringa
return 0;
}
P.S. Per la cronaca, se [i]tuchinén è un pezzettino, direi che dovrebbe essere ovvio che un tòc è un pezzo di medie dimensioni.'
// alla posizione inizio+lToc
aux = *(inizio+lToc);
*(inizio+lToc) = '"Giusto per" (gran bella cosa le ferie!), m'è venuto il ghiribizzo di provare a fare una specie di "strtok() dei poveri" procedendo di testa mia.
Dal momento che mi ha sempre sconfifferato poco il fatto che la strtok() vera abbia questa specie di "persistenza", mi son detto: "la mia NON deve memorizzare alcun indice tra le chiamate". In più, giocherellando, mi sono accorto che la strtok() vera non ammette l'esistenza di elementi "vuoti", ovvero che se ci sono due terminatori adiacenti, l'elemento "vuoto" che ci si aspetterebbe di trovarci in mezzo viene omesso, saltato, ignorato... a me sembra un comportamento un po' strano.
Edit:: in più, ancora, strtok() modifica la stringa originale (infatti le si passa un char* e non un const char*) inzuppandola di terminatori.
Dunque, ho messo insieme Tuchinen(). Un particolare importante è che il nome della funzione si legge "Tuchinén", parola che significa "pezzettino". Mi sarebbe piaciuto anche chiamarla "strok!", come quando uno si becca una fregatura e... "STROK!", però l'assonanza sarebbe stata eccessiva e mi sarebbero magari state contestate questioni di copyright.
Donca, ciapa's tuchinén e lasla bùi, nuiùs d'in nuiùs!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TIPO_ESEMPIO 1 // tra 0 e 6, per provare 7 situazioni diverse
#if TIPO_ESEMPIO == 0
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen|quarto tuchen";
#elif TIPO_ESEMPIO == 1
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen";
#elif TIPO_ESEMPIO == 2
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen|";
#elif TIPO_ESEMPIO == 3
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 4
char gStrEsempio[] = "|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 5
char gStrEsempio[] = "";
#elif TIPO_ESEMPIO == 6
char *gStrEsempio = NULL;
#endif // switch TIPO_ESEMPIO
/*==============================================================================
Analizza la stringa C contenuta nell'array di caratteri che parte da "inizio" in
cerca di uno qualsiasi tra i caratteri contenuti nella stringa C contenuta
nell'array "sep". Appena trova la prima occorrenza di uno di quei caratteri ne
memorizza il puntatore in "fine" e restituisce la quantita' dei caratteri
compresi tra inizio (compreso) e fine (escluso).
Se viene raggiunta la fine della stringa C contenuta nell'array "inizio" senza
che sia stato trovato alcuno dei caratteri ricercati, in "fine" viene inserito
un puntatore NULL.
Se "inizio" e' un puntatore NULL, anche "fine" sara' un puntatore NULL e la
funzione restituira' -1 (chiaramente una lunghezza non valida per qualsivoglia
stringa).
Se "inizio" punta a una stringa vuota, si considera comunque che contenga un
elemento, perche' anche una stringa costituita dal solo terminatore e' comunque
un elemento valido (una stringa lunga zero caratteri).
==============================================================================*/
int Tuchinen( const char *inizio, char **fine, const char *sep ) {
if( inizio )
return (*fine=strpbrk(inizio,sep)) ? *fine-inizio : strlen(inizio);
else { *fine = NULL; return -1; }
}
/*==============================================================================
Un programmino da intendere come esempio e come test.
Cerca gli elementi contenuti nella stringa gStrEsempio (definita in piu'
versioni in testa alla pagina) usando come separatore il solo carattere "|"
(puo' essere interessante provare a usare due separatori contemporaneamente, ad
esempio passando "| " o qualsiasi altra cosa).
==============================================================================*/
int main() {
char *inizio = NULL; // puntatore ausiliario
char *fine = NULL; // puntatore ausiliario
int totToc = 0; // la quantita' degli elementi rilevati
int lToc = 0; // la lunghezza dell'elemento corrente
char aux = '{parsed_message}'; // carattere ausiliario
inizio = gStrEsempio; // da dove cominciare?
do {
// la chiamata alla funzione da provare
lToc = Tuchinen( inizio, &fine, "|" );
if( lToc >= 0 ) { // se lToc fosse minore di zero, significherebbe
// che non e' stato trovato alcun elemento valido
// per poter stampare la stringa di lToc caratteri che parte da
// "inizio", occorre inserire TEMPORANEAMENTE un terminatore '{parsed_message}'
// alla posizione inizio+lToc
aux = *(inizio+lToc);
*(inizio+lToc) = '{parsed_message}';
// visualizza un po' di informazioni
printf( "%4d. \"%s\" (%d caratteri)\n", ++totToc, inizio, lToc );
// ripristina il carattere temporaneamente
// sostituito con il carattere terminatore '{parsed_message}'
*(inizio+lToc) = aux;
// il carattere puntato da "fine" e' un separatore;
// la nuova ricerca dovra' partire dal carattere successivo
inizio=fine+1; // per questo, "+1"
}
else {
// non sono ammessi puntatori NULL
printf( "Puntatore NULL, caprone!\n" );
}
} while( fine ); // se "fine" e' NULL vuol dire
// che si e' in fondo alla stringa
return 0;
}
P.S. Per la cronaca, se [i]tuchinén è un pezzettino, direi che dovrebbe essere ovvio che un tòc è un pezzo di medie dimensioni.';
// visualizza un po' di informazioni
printf( "%4d. \"%s\" (%d caratteri)\n", ++totToc, inizio, lToc );
// ripristina il carattere temporaneamente
// sostituito con il carattere terminatore '"Giusto per" (gran bella cosa le ferie!), m'è venuto il ghiribizzo di provare a fare una specie di "strtok() dei poveri" procedendo di testa mia.
Dal momento che mi ha sempre sconfifferato poco il fatto che la strtok() vera abbia questa specie di "persistenza", mi son detto: "la mia NON deve memorizzare alcun indice tra le chiamate". In più, giocherellando, mi sono accorto che la strtok() vera non ammette l'esistenza di elementi "vuoti", ovvero che se ci sono due terminatori adiacenti, l'elemento "vuoto" che ci si aspetterebbe di trovarci in mezzo viene omesso, saltato, ignorato... a me sembra un comportamento un po' strano.
Edit:: in più, ancora, strtok() modifica la stringa originale (infatti le si passa un char* e non un const char*) inzuppandola di terminatori.
Dunque, ho messo insieme Tuchinen(). Un particolare importante è che il nome della funzione si legge "Tuchinén", parola che significa "pezzettino". Mi sarebbe piaciuto anche chiamarla "strok!", come quando uno si becca una fregatura e... "STROK!", però l'assonanza sarebbe stata eccessiva e mi sarebbero magari state contestate questioni di copyright.
Donca, ciapa's tuchinén e lasla bùi, nuiùs d'in nuiùs!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TIPO_ESEMPIO 1 // tra 0 e 6, per provare 7 situazioni diverse
#if TIPO_ESEMPIO == 0
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen|quarto tuchen";
#elif TIPO_ESEMPIO == 1
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen";
#elif TIPO_ESEMPIO == 2
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen|";
#elif TIPO_ESEMPIO == 3
char gStrEsempio[] = "primo tuchen|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 4
char gStrEsempio[] = "|secondo tuchen|terzo tuchen||quinto tuchen||";
#elif TIPO_ESEMPIO == 5
char gStrEsempio[] = "";
#elif TIPO_ESEMPIO == 6
char *gStrEsempio = NULL;
#endif // switch TIPO_ESEMPIO
/*==============================================================================
Analizza la stringa C contenuta nell'array di caratteri che parte da "inizio" in
cerca di uno qualsiasi tra i caratteri contenuti nella stringa C contenuta
nell'array "sep". Appena trova la prima occorrenza di uno di quei caratteri ne
memorizza il puntatore in "fine" e restituisce la quantita' dei caratteri
compresi tra inizio (compreso) e fine (escluso).
Se viene raggiunta la fine della stringa C contenuta nell'array "inizio" senza
che sia stato trovato alcuno dei caratteri ricercati, in "fine" viene inserito
un puntatore NULL.
Se "inizio" e' un puntatore NULL, anche "fine" sara' un puntatore NULL e la
funzione restituira' -1 (chiaramente una lunghezza non valida per qualsivoglia
stringa).
Se "inizio" punta a una stringa vuota, si considera comunque che contenga un
elemento, perche' anche una stringa costituita dal solo terminatore e' comunque
un elemento valido (una stringa lunga zero caratteri).
==============================================================================*/
int Tuchinen( const char *inizio, char **fine, const char *sep ) {
if( inizio )
return (*fine=strpbrk(inizio,sep)) ? *fine-inizio : strlen(inizio);
else { *fine = NULL; return -1; }
}
/*==============================================================================
Un programmino da intendere come esempio e come test.
Cerca gli elementi contenuti nella stringa gStrEsempio (definita in piu'
versioni in testa alla pagina) usando come separatore il solo carattere "|"
(puo' essere interessante provare a usare due separatori contemporaneamente, ad
esempio passando "| " o qualsiasi altra cosa).
==============================================================================*/
int main() {
char *inizio = NULL; // puntatore ausiliario
char *fine = NULL; // puntatore ausiliario
int totToc = 0; // la quantita' degli elementi rilevati
int lToc = 0; // la lunghezza dell'elemento corrente
char aux = '{parsed_message}'; // carattere ausiliario
inizio = gStrEsempio; // da dove cominciare?
do {
// la chiamata alla funzione da provare
lToc = Tuchinen( inizio, &fine, "|" );
if( lToc >= 0 ) { // se lToc fosse minore di zero, significherebbe
// che non e' stato trovato alcun elemento valido
// per poter stampare la stringa di lToc caratteri che parte da
// "inizio", occorre inserire TEMPORANEAMENTE un terminatore '{parsed_message}'
// alla posizione inizio+lToc
aux = *(inizio+lToc);
*(inizio+lToc) = '{parsed_message}';
// visualizza un po' di informazioni
printf( "%4d. \"%s\" (%d caratteri)\n", ++totToc, inizio, lToc );
// ripristina il carattere temporaneamente
// sostituito con il carattere terminatore '{parsed_message}'
*(inizio+lToc) = aux;
// il carattere puntato da "fine" e' un separatore;
// la nuova ricerca dovra' partire dal carattere successivo
inizio=fine+1; // per questo, "+1"
}
else {
// non sono ammessi puntatori NULL
printf( "Puntatore NULL, caprone!\n" );
}
} while( fine ); // se "fine" e' NULL vuol dire
// che si e' in fondo alla stringa
return 0;
}
P.S. Per la cronaca, se [i]tuchinén è un pezzettino, direi che dovrebbe essere ovvio che un tòc è un pezzo di medie dimensioni.'
*(inizio+lToc) = aux;
// il carattere puntato da "fine" e' un separatore;
// la nuova ricerca dovra' partire dal carattere successivo
inizio=fine+1; // per questo, "+1"
}
else {
// non sono ammessi puntatori NULL
printf( "Puntatore NULL, caprone!\n" );
}
} while( fine ); // se "fine" e' NULL vuol dire
// che si e' in fondo alla stringa
return 0;
}
P.S. Per la cronaca, se [i]tuchinén è un pezzettino, direi che dovrebbe essere ovvio che un
tòc è un pezzo di medie dimensioni.
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.