[C] Sostituire 1 sottostringa in 1 stringa: ho fatto questa funzione..

[Matrixbob]

... ma a quanto pare va in coredump!

void sostituisci(char *str_input, char *str_target, char *str_sostituta)
{
int allargare, stringere, i;
int size_target=strlen(str_target), size_sostituta=strlen(str_sostituta);
char *str_trovata, *str_marker, *str_tmp;

str_trovata = strstr(str_input, str_target);

if (str_trovata != "NULL")
{   //ALLARGARE
    if (size_sostituta>size_target)
        {
        allargare = size_sostituta - size_target;
        str_marker = str_trovata;
        for(i=0; i<size_target; ++i) { str_marker++; } //piazzo il marker
        while(*str_input) { str_input++; } //vado a fondo stringa
        str_tmp = str_input++; //il temporaneo punta oltre
        for(i=0; i<allargare; ++i)
            {
            do {
               *str_tmp = *str_input;
                str_tmp--;
                str_input--;
               } while(str_input!=str_marker);
            }
        }
    //STRINGERE
    if (size_sostituta<size_target)
        {
        stringere = size_target - size_sostituta;
        for(i=0; i<size_sostituta; ++i)
            {
            *str_trovata=*str_sostituta;
            str_trovata++;
            str_sostituta++;
            }
        str_marker = str_trovata--; //piazzo il marker
        for(i=0; i<stringere; ++i)
            {
            do {
               *str_marker = *str_trovata;
                str_marker++;
                str_trovata++;
               } while(*str_trovata);
            }
        }
    //DIMENSIONE OK
    if (size_sostituta==size_target)
        {
        for(i=0; i<size_target; ++i)
            {
            *str_trovata=*str_sostituta;
            str_trovata++;
            str_sostituta++;
            }
        }
}
}

[Matrixbob]

Voi come fareste?!
... e pensare che ci ho lavorato 2 ore e 1/2.

[Matrixbob]

Versione con stampe di controllo e richiesta di pressione tasto x continuare:

void sostituisci(char *str_input, char *str_target, char *str_sostituta)
{
int allargare, stringere, i;
int size_target=strlen(str_target), size_sostituta=strlen(str_sostituta);
char *str_trovata, *str_marker, *str_tmp;

str_trovata = strstr(str_input, str_target);

printf("size_target: %d, size_sostituta: %d\n\n", size_target, size_sostituta);
getchar();

if (str_trovata != "NULL")
{   //ALLARGARE
    if (size_sostituta>size_target)
        {
        printf("ALLARGO\n\n");
        getchar();
        allargare = size_sostituta - size_target;
        str_marker = str_trovata;
        for(i=0; i<size_target; ++i) { str_marker++; } //piazzo il marker
        while(*str_input) { str_input++; } //vado a fondo stringa
        str_tmp = str_input++; //il temporaneo punta oltre
        for(i=0; i<allargare; ++i)
            {
            do {
               *str_tmp = *str_input;
                str_tmp--;
                str_input--;
               } while(str_input!=str_marker);
            }
        }
    //STRINGERE
    if (size_sostituta<size_target)
        {
        printf("STRINGO\n\n");
        getchar();
        stringere = size_target - size_sostituta;
        for(i=0; i<size_sostituta; ++i)
            {
            *str_trovata=*str_sostituta;
            str_trovata++;
            str_sostituta++;
            }
        str_marker = str_trovata--; //piazzo il marker
        for(i=0; i<stringere; ++i)
            {
            do {
               *str_marker = *str_trovata;
                str_marker++;
                str_trovata++;
               } while(*str_trovata);
            }
        }
    //DIMENSIONE OK
    if (size_sostituta==size_target)
        {
        printf("DIMESIONE OK\n\n");
        getchar();
        for(i=0; i<size_target; ++i)
            {
            *str_trovata=*str_sostituta;
            str_trovata++;
            str_sostituta++;
            }
        }
}
}

Io per esempio adesso la sto richiamando così:

sostituisci(buffer2, "<br>", "\n");

[andbin]

Se si vuole realizzare una funzione di sostituzione molto "generica", è necessario tenere in considerazione due cose:
a) La stringa di sostituzione potrebbe essere più lunga della stringa da trovare.
b) Ci potrebbero essere più occorrenze della stringa da trovare.

Per questo motivo, credo che sia molto più valido far restituire alla funzione una stringa allocata dinamicamente. La funzione si preoccuperà di (ri)allocare espandendo la stringa quando serve.

Se vuoi posso eventualmente postare la "mia" soluzione generica.

[Matrixbob]

Originariamente inviato da andbin

Se si vuole realizzare una funzione di sostituzione molto "generica", è necessario tenere in considerazione due cose:
a) La stringa di sostituzione potrebbe essere più lunga della stringa da trovare.
b) Ci potrebbero essere più occorrenze della stringa da trovare.

Per questo motivo, credo che sia molto più valido far restituire alla funzione una stringa allocata dinamicamente. La funzione si preoccuperà di (ri)allocare espandendo la stringa quando serve.

Se vuoi posso eventualmente postare la "mia" soluzione generica.

Certo posta pure, tanto la mia è AFunzionale.

[andbin]

Io l'ho fatta così:

char *subst_string (char *str, char *search, char *subst)
{
    size_t len_search, len_subst, len_r, len_s;
    size_t size = 0, capacity = 0, expand = 256;
    char *start = str, *p, *output = NULL, *output_new;

    len_search = strlen (search);
    len_subst = strlen (subst);

    do {
        p = strstr (start, search);

        if (p != NULL)
        {
            len_r = p - start;
            len_s = len_subst;
        }
        else
        {
            len_r = strlen (start);
            len_s = 0;
        }

        if ((size + len_r + len_s + 1) > capacity)
        {
            capacity = size + len_r + len_s + 1 + expand;
            output_new = (char*) realloc (output, capacity);

            if (output_new == NULL)
            {
                free (output);
                return NULL;
            }

            output = output_new;
        }

        strncpy (&output[size], start, len_r);
        size += len_r;
        strncpy (&output[size], subst, len_s);
        size += len_s;

        start += len_r + len_search;
    } while (p != NULL);

    output[size] = '\0';

    output_new = (char*) realloc (output, size+1);

    if (output_new != NULL)
        output = output_new;

    return output;
}

[Matrixbob]

L'ho provata ora e funziona benissimo.
Grazie ancora Andbin per tutto l'aiuto che ci dai.

[LOVE85]

Mi sono permesso di provare in questo modo il codice ma non riesco a farlo funzionare:

Eccolo qui:

#include <stdio.h>
#include <stdlib.h>

char *subst_string (char *, char *, char *);

int main()
{
    char stringa1[50];
    char cercare[10];
    char sostituire[10];
    char newstringa[50];

    printf("Inserisci la stringa di cui cambiare la sottostringa:\n\n");
    scanf("%s",&stringa1);
    printf("Inserisci la parola da cercare e......:\n\n");
    scanf("%s",&cercare);
    printf(".....sostituire con:\n\n");
    scanf("%s",&sostituire);
    subst_string(stringa1,cercare,sostituire);
    printf(stringa1);
    system("pause");   
}    
    


char *subst_string (char *str, char *search, char *subst)
{
    size_t len_search, len_subst, len_r, len_s;
    size_t size = 0, capacity = 0, expand = 256;
    char *start = str, *p, *output = NULL, *output_new;

    len_search = strlen (search);
    len_subst = strlen (subst);

    do {
        p = strstr (start, search);

        if (p != NULL)
        {
            len_r = p - start;
            len_s = len_subst;
        }
        else
        {
            len_r = strlen (start);
            len_s = 0;
        }

        if ((size + len_r + len_s + 1) > capacity)
        {
            capacity = size + len_r + len_s + 1 + expand;
            output_new = (char*) realloc (output, capacity);

            if (output_new == NULL)
            {
                free (output);
                return NULL;
            }

            output = output_new;
        }

        strncpy (&output[size], start, len_r);
        size += len_r;
        strncpy (&output[size], subst, len_s);
        size += len_s;

        start += len_r + len_search;
    } while (p != NULL);

    output[size] = '\0';

    output_new = (char*) realloc (output, size+1);

    if (output_new != NULL)
        output = output_new;

    return output;
}

Chi mi aiuta a fare questo programa con la funzione implementata da Andbin?

Grazie
PS: Chiedo scusa ad Andbin se per caso non mi sono permesso di utilizzare la sua implementazione.
Grazie

[labrosan]

Ciao,

innanzitutto devi includere string.h.
Ci sono diversi errori nel main. Questa è la versione corretta:

printf("Inserisci la stringa di cui cambiare la sottostringa:\n\n");
gets(stringa1);
printf("Inserisci la parola da cercare e......:\n\n");
scanf("%s",cercare);
printf(".....sostituire con:\n\n");
scanf("%s",sostituire);
printf("%s",subst_string(stringa1,cercare,sostituire));
system("pause");

Per leggere una stringa intera non puoi usare la scanf, perchè legge solo una parola. Quando fai la scanf di cercare e sostituire non serve l'operatore &, perchè le stringhe sono gia puntatori. La funzione di Andbin restituisce una stringa, non modifica la stringa1.

[LOVE85]

E se volessi togliere (2° funz) la parola cercata? e poi aggiungere (3° funz)
Perchè la 1° è sostituisci.
Se volessi togliere la parola perchè non basta mettere:

sostituire = ' '; ? Grazie Coridali saluti
Cris

[LOVE85]

Ciao, scusate l'ora di stanotte ma non ho dormito perchè siccome mi manca la mia ragazza e per vivere con lei mi sto dando da fare.......capito....se avete comunque visto l'ora strana...dell'ultimo post è perchè non dormo più....comunque lasciamo da parte la mia tristezza....vorrei chiedere a Andbin se può commentare il codice ok? Grazie
Cordiali Saluti

[LOVE85]

Da come ho capito invece della programmazione maledetta del C ( infatti preferisco più Visual Basic + semplice) mi sembra di capire così:

#include <stdio.h> /*inclusione della libreria standard input/output */
#include <stdlib.h> /*inclusione della libreria standard del sistema */
#include <string.h> /*inclusione della libreria per manipolare stringhe */

char *subst_string (char *, char *, char *); /*prototipo funzione sostitiusci */

int main() /*inizio*/
{
    /// DICHIARAZIONI CHARACTER VARIABILI UTILIZZATE NEL PROGRAMMA ///
    char stringa1[50];
    char cercare[10];
    char sostituire[10];
    char newstringa[50];

   /////////////////////////////////////////////////////////////////
 
    printf("Inserisci la stringa di cui cambiare la sottostringa:\n\n");
    gets(stringa1);
    printf("Inserisci la parola da cercare e......:\n\n");
    scanf("%s",cercare);
    printf(".....sostituire con:\n\n");
    scanf("%s",sostituire);
    printf("%s",subst_string(stringa1,cercare,sostituire));
    printf("\n\n\n");
    system("pause");  
}    
    


char *subst_string (char *str, char *search, char *subst)
{
    size_t len_search, len_subst, len_r, len_s; ?
    size_t size = 0, capacity = 0, expand = 256; ?
    char *start = str, *p, *output = NULL, *output_new; ?

    len_search = strlen (search); /*lunghezza della parola da cercare */
    len_subst = strlen (subst); /lunghezza della sottostringa sostituente */

    do {
        p = strstr (start, search); ?

        if (p != NULL)
        {
            len_r = p - start;
            len_s = len_subst;
        }
        else
        {
            len_r = strlen (start);
            len_s = 0;
        }

        if ((size + len_r + len_s + 1) > capacity)
        {
            capacity = size + len_r + len_s + 1 + expand;
            output_new = (char*) realloc (output, capacity);

            if (output_new == NULL)
            {
                free (output);
                return NULL;
            }

            output = output_new;
        }

        strncpy (&output[size], start, len_r);
        size += len_r;
        strncpy (&output[size], subst, len_s);
        size += len_s;

        start += len_r + len_search;
    } while (p != NULL);

    output[size] = '\0';

    output_new = (char*) realloc (output, size+1);

    if (output_new != NULL)
        output = output_new;

    return output;
}

Il resto conosco più o meno i tipi di allocazione della memoria come malloc, calloc, realloc fatte in laboratorio....e la loro "liberazione" o meglio pulizia o ancora meglio svuotamento della memoria attraverso lafunzione free()....
ma non ho capito bene i passi che fa questo programma...ecco perchè chiedo di commentare per capire bene il codice......e per imparare per il futuro.
Grazie

[LOVE85]

.....e quindi: . Grazie
Ciao Ciao
Topic da chiudere

[Matrixbob]

Originariamente inviato da LOVE85

.....e quindi: . Grazie
Ciao Ciao
Topic da chiudere

Topic da chiudere perchè lo dici tu?
Il topic sarebbe da chiudere perchè Andbin ha dato la soluzione migliore fin ora, sicuramente NON per i tuoi interventi.
Un forum serve per collaborare e non per trovare la pappa pronta.
Andbin è già andato oltre al suo compito, non è 1 professore che ti prende manina e ti porta a spasso nel suo codice.
Per quello ci sono i manuali.

[Furla]

Originariamente inviato da LOVE85

... programmazione maledetta del C ( infatti preferisco più Visual Basic + semplice) ...

più facile, vorrai dire... più semplice non credo proprio.

[Fede_Reghe]

Scusate se mi intrometto... Ma al posto di creare una funzione così lunga che rallenta il codice, utilizzare le funzioni che già esistono (definite in string.h) no?

[Matrixbob]

Originariamente inviato da Fede_Reghe

Scusate se mi intrometto... Ma al posto di creare una funzione così lunga che rallenta il codice, utilizzare le funzioni che già esistono (definite in string.h) no?

Tipo quale? Io non ne ho trovate che facciano questo lavoro.