Newsgroup: it.comp.lang.c
Titolo: [C] chiarimenti di alcune funzioni

Ciao, sto imparando il C ma siccome provengo da Visual Basic vi chiedo
se potete aiutarmi spiegandomi quali sono le funzioni che
sostituiscono quelle che conosco, ovvero:
x= Mid(str,1,1)
y= Left(str,1)
z= Right(str,1)
w= trim(str)
Grazie mille!

 wrote in message
news:807eeb84.03061...@posting.google.com

Semplice, in "C" standard non esistono. Le operazioni sulle stringhe
devi farle a manina utilizzando puntatori o facendo copie.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 x= Mid(str,1,1)
Se il terzo parametro č 1 questa č abbastanza semplice:
char x = str[0]; /* 0 č il secondo parametro della Mid meno uno */
Steve.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 w= trim(str)
Immagino che tu voglia eliminare dalle estremita' sinistra e destra di str,
tutti gli spazi e i tab.
Farlo non e' immediato, perche' dipende da cosa vuio fare con la stringa: in
generale e' preferibile una funzione (meglio 2) che semplicemente ti
delimitino le parti di stringa "buone".
Ti posto 2 funzioni che si occupano di fare il trim a sinistra ed a destra
di un qualunque insieme di caratteri.
<code>
char * str_rtrim_of (const char *s, const char *t)
{
    const char *si, *ti;
    if (!(s && t))
        return NULL;
    si = s;
    while(*si)
        si++;
    for(si--; s != si; ) {
        ti = t;
        while(*ti) {
            if (*si == *ti) {
                si--;
                break;
            }
            ti++;
        }
        if (*ti == '\0')
            return (char *)(si+1);
    }
    return (char *)(si+1);
}
</code>
Se non dico cavolate, questa ritorna l'ultimo carattere della stringa in
input che NON va' scartato.
A sinistra e' molto piu' facile:
<code>
#define str_ltrim_of(s,t) ((s)==(NULL)?(NULL):(s)+strspn((s),(t)))
</code>
Questa se non sbaglio ritorna il primo carattere di S che non va' scartato.
Una volta che hai i 2 puntatori SE vuoi una nuova stringa contenente solo la
parte che ti interessa della stringa, fai:
<code>
char * stringa = "__  _ __ciao come stai___ __";
char *left, *right, result;
ptrdiff_t size;
left  = str_ltrim_of (stringa, "_ ");
right = str_rtrim_of (stringa, "_ ");
/*il +1 per come ho implementato la str_rtrim_of */
size = right-left+1; 
/* serve anche un '\0' finale */
result = malloc(size+1);
if (result) {
    strncpy(result, stringa+left, size);
    result[size] = '\0';
}
</code>
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 z= Right(str,1)
Non ricordo come funzionavano esattamente in VB. La mia implementazione
prevede che:
* gli indici delle stringhe partono da 0
* se non e` possibile eseguire l'operazione (ie malloc fallita oppure
  lunghezza richiesta > lunghezza della stringa) viene restituito NULL.
* e` ammissibile una lunghezza 0 (restituisce una stringa vuota)
#include <string.h>
#include <stdlib.h>
char *mid(char const *str, int start, int len) {
	int l = strlen(str);
	char *ret;
	if (start > l || len > (l - start))
		return NULL;
	ret = malloc(len + 1);
        if (ret == NULL)
                return NULL;
	memcpy(ret, str + start, len);
	ret[len] = '\0';
	return ret;
}
char *left(char const *str, int len) {
	int l = strlen(str);
	char *ret;
	if (len > l)
		return NULL;
	ret = malloc(len + 1);
        if (ret == NULL)
                return NULL;
	memcpy(ret, str, len);
	ret[len] = '\0';
	return ret;
}
char *right(char const *str, int len) {
	int l = strlen(str);
	char *ret;
	if (len > l)
		return NULL;
	ret = malloc(len + 1);
        if (ret == NULL)
                return NULL;
	memcpy(ret, str + l - len, len);
	ret[len] = '\0';
	return ret;
}
Ricorda,  pero`, che  in C  non  puoi usare  le stringhe  con la  stessa
disinvoltura del VB. Ad  esempio devi ricordarti di  liberare la memoria
allocata da queste funzioni.
Kronos
-- 
Home: 
http://kronoz.cjb.net
Una donna sposa un uomo sperando che cambi, e lui non cambiera`. Un
uomo sposa una donna sperando che non cambi, e lei cambiera`.