C/C++ - Eliminare degli elementi da un array di caratteri e ricompattarlo..

Buonasera a tutti, il mio problema è il seguente, e ci sto un poco sbattendo la testa: Avendo due stringhe, allora si devono trovare le occorrenze della prima stringa nella seconda (ovviamente la seconda è più grande della prima) e le si devono eliminare col minor numero di spostamenti di memoria possibile.

La soluzione che ho pensato è la seguente: in un primo momento trovo tutte le occorrenze nella stringa e salvo le posizione della corrispondenza in un array di interi. Se la stringa da cercare si ripete due volte in modo consecutivo nella stringa allora l'ultima posizione salvata nell'array delle posizioni viene aggiornata, in modo che quando verrà eseguito lo spostamento di memoria per compattare l'array, non dovrà eseguirlo due volte, ma solo una volta per quella specifica area (non so se ho lasciato intendere). Il punto è proprio questo, ho individuato le aree da eliminare, ed ho anche l'array delle posizioni, ma non riesco a compattare l'array eliminando quelle aree specifiche.

Questo è il codice:

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

char * string_del(char *, char *);

int main(int argc, char *argv[]) {
	char *string = "acacrsssdstgfdfgdacacddf", *chr = "ac"; 
	string_del(string, chr);
}

char * string_del(char *string, char *chr) {
	int fs_pos, sc_pos, i = 0, j = 0, *pos_array;
	pos_array = (int *)calloc(0, sizeof(int)); 
	
	for(i = 0; *(string + i) != 'Buonasera a tutti, il mio problema è il seguente, e ci sto un poco sbattendo la testa: Avendo due stringhe, allora si devono trovare le occorrenze della prima stringa nella seconda (ovviamente la seconda è più grande della prima) e le si devono eliminare col minor numero di spostamenti di memoria possibile. 



La soluzione che ho pensato è la seguente: in un primo momento trovo tutte le occorrenze nella stringa e salvo le posizione della corrispondenza in un array di interi. Se la stringa da cercare si ripete due volte in modo consecutivo nella stringa allora l'ultima posizione salvata nell'array delle posizioni viene aggiornata, in modo che quando verrà eseguito lo spostamento di memoria per compattare l'array, non dovrà eseguirlo due volte, ma solo una volta per quella specifica area (non so se ho lasciato intendere). Il punto è proprio questo, ho individuato le aree da eliminare, ed ho anche l'array delle posizioni, ma non riesco a compattare l'array eliminando quelle aree specifiche. 



Questo è il codice: 



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

char * string_del(char *, char *);

int main(int argc, char *argv[]) {
	char *string = "acacrsssdstgfdfgdacacddf", *chr = "ac"; 
	string_del(string, chr);
}

char * string_del(char *string, char *chr) {
	int fs_pos, sc_pos, i = 0, j = 0, *pos_array;
	pos_array = (int *)calloc(0, sizeof(int)); 
	
	for(i = 0; *(string + i) != '{parsed_message}'; i++) {
		if(strncmp(string + i, chr, strlen(chr)) == 0) {
			if((sc_pos + 1) == i) {
				sc_pos = i + strlen(chr) - 1;
				*(pos_array + j) = sc_pos;
				j++;  
			} else {
				fs_pos = i; 
				sc_pos = i + strlen(chr) - 1;
				
				if(realloc(pos_array, (j)*2 + 1) != NULL) {
					*(pos_array + j) = fs_pos; 
					*(pos_array + j + 1) = sc_pos;
					j++;  
				}
			}
		}
	} printf("\n");

	for(i = 0; i < j; i += 2) {
		int size = *(pos_array + i + 1) - *(pos_array + i); 
		char dest = *(string + *(pos_array + i)); 
		char src = *(string + *(pos_array + i + 1));
		
		printf("DEST: %c\tSRC: %c\tSIZE: %d\n", dest, src, size);

                // In questa sezione del codice dovrei eseguire l'eliminazione e lo spostamento degli elementi. 
	}
}
'; i++) {
		if(strncmp(string + i, chr, strlen(chr)) == 0) {
			if((sc_pos + 1) == i) {
				sc_pos = i + strlen(chr) - 1;
				*(pos_array + j) = sc_pos;
				j++;  
			} else {
				fs_pos = i; 
				sc_pos = i + strlen(chr) - 1;
				
				if(realloc(pos_array, (j)*2 + 1) != NULL) {
					*(pos_array + j) = fs_pos; 
					*(pos_array + j + 1) = sc_pos;
					j++;  
				}
			}
		}
	} printf("\n");

	for(i = 0; i < j; i += 2) {
		int size = *(pos_array + i + 1) - *(pos_array + i); 
		char dest = *(string + *(pos_array + i)); 
		char src = *(string + *(pos_array + i + 1));
		
		printf("DEST: %c\tSRC: %c\tSIZE: %d\n", dest, src, size);

                // In questa sezione del codice dovrei eseguire l'eliminazione e lo spostamento degli elementi. 
	}
}

Se lo scopo è ridurre gli spostamenti di memoria io risolverei così:

#include <stdio.h>
#include <string.h>

//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================

char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );

        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;

            // in str, sostituisce con 'Se lo scopo è ridurre gli spostamenti di memoria io risolverei così:



#include <stdio.h>
#include <string.h>

//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================

char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );

        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;

            // in str, sostituisce con '{parsed_message}'
            // le sottostringhe da eliminare
            while( pStr ) {
                memset( pStr, 0, lRem );
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }

            // "compatta" la stringa eliminando
            // gli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

            *pStr = '{parsed_message}'; // termina la stringa
        }
    }

    return str; // restituisce l'indirizzo ricevuto in str
}

// Esempio d'uso

int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}
'
            // le sottostringhe da eliminare
            while( pStr ) {
                memset( pStr, 0, lRem );
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }

            // "compatta" la stringa eliminando
            // gli 'Se lo scopo è ridurre gli spostamenti di memoria io risolverei così:



#include <stdio.h>
#include <string.h>

//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================

char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );

        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;

            // in str, sostituisce con '{parsed_message}'
            // le sottostringhe da eliminare
            while( pStr ) {
                memset( pStr, 0, lRem );
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }

            // "compatta" la stringa eliminando
            // gli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

            *pStr = '{parsed_message}'; // termina la stringa
        }
    }

    return str; // restituisce l'indirizzo ricevuto in str
}

// Esempio d'uso

int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}
' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

            *pStr = 'Se lo scopo è ridurre gli spostamenti di memoria io risolverei così:



#include <stdio.h>
#include <string.h>

//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================

char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );

        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;

            // in str, sostituisce con '{parsed_message}'
            // le sottostringhe da eliminare
            while( pStr ) {
                memset( pStr, 0, lRem );
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }

            // "compatta" la stringa eliminando
            // gli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

            *pStr = '{parsed_message}'; // termina la stringa
        }
    }

    return str; // restituisce l'indirizzo ricevuto in str
}

// Esempio d'uso

int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}
'; // termina la stringa
        }
    }

    return str; // restituisce l'indirizzo ricevuto in str
}

// Esempio d'uso

int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}

Innanzitutto ti ringrazio per la risposta e il tempo speso per elaborare questa soluzione. Avevo pensato anche io di risolverlo con questo metodo, ossia di sostituire le occorrenze con degli "0" o "-" e poi andare ad eliminarle successivamente, cosa che però non mi è riuscita in quanto non sono riuscito a sostituire i caratteri nella stringa come hai fatto tu utilizzando la funzione memset().

Ho studiato la tua soluzione e la gran parte del codice l'ho capito, e l'ho rielaborato nel mio codice (cosi da capirlo ancora meglio).
Quello che non ho capito però è questo punto:

// "compatta" la stringa eliminando
// gli 'Innanzitutto ti ringrazio per la risposta e il tempo speso per elaborare questa soluzione. Avevo pensato anche io di risolverlo con questo metodo, ossia di sostituire le occorrenze con degli "0" o "-" e poi andare ad eliminarle successivamente, cosa che però non mi è riuscita in quanto non sono riuscito a sostituire i caratteri nella stringa come hai fatto tu utilizzando la funzione memset().



Ho studiato la tua soluzione e la gran parte del codice l'ho capito, e l'ho rielaborato nel mio codice (cosi da capirlo ancora meglio). 

Quello che non ho capito però è questo punto: 

// "compatta" la stringa eliminando
// gli '{parsed_message}' immessi in precedenza
            
for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
  if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
*pStr = '{parsed_message}'; // termina la stringa


L'intestazione del ciclo FOR l'ho capita, ma quella del controllo no. ' immessi in precedenza
            
for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
  if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
*pStr = 'Innanzitutto ti ringrazio per la risposta e il tempo speso per elaborare questa soluzione. Avevo pensato anche io di risolverlo con questo metodo, ossia di sostituire le occorrenze con degli "0" o "-" e poi andare ad eliminarle successivamente, cosa che però non mi è riuscita in quanto non sono riuscito a sostituire i caratteri nella stringa come hai fatto tu utilizzando la funzione memset().



Ho studiato la tua soluzione e la gran parte del codice l'ho capito, e l'ho rielaborato nel mio codice (cosi da capirlo ancora meglio). 

Quello che non ho capito però è questo punto: 

// "compatta" la stringa eliminando
// gli '{parsed_message}' immessi in precedenza
            
for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
  if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
*pStr = '{parsed_message}'; // termina la stringa


L'intestazione del ciclo FOR l'ho capita, ma quella del controllo no. '; // termina la stringa

L'intestazione del ciclo FOR l'ho capita, ma quella del controllo no.

Avete la funzione di libreria strstr, il numero di caratteri residui è lunghezza_stringa - (lunghezza_sotto stringa * numero_verificato_match) il numero massimo di match lo sapete a priori, potete mettere gli inizi di stringa in un array e poi copiare la stringa.

Comunque il numero minimo di copie in memoria è il numero di caratteri da non rimuovere....

for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

Ci son due coccodrilli... anzi, no, due puntatori che tengono traccia l'uno (pStr) dell'avanzamento del punto nel quale vengono copiati i caratteri da tenere, l'altro (pRem) dell'avanzamento del punto dal quale vengono prelevati i caratteri da copiare (tutti tranne gli 'for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

Ci son due coccodrilli... anzi, no, due puntatori che tengono traccia l'uno (pStr) dell'avanzamento del punto nel quale vengono copiati i caratteri da tenere, l'altro (pRem) dell'avanzamento del punto dal quale vengono prelevati i caratteri da copiare (tutti tranne gli '{parsed_message}').

Inizialmente entrambi i puntatori combaciano con l'indirizzo d'inizio della stringa dalla quale rimuovere la sottostringa. Il ciclo procede fino a che la differenza tra il puntatore "di prelievo" e quello "di destinazione" è minore della lunghezza della stringa str, ovvero fino a che si arriva in fondo alla stringa stessa.

Il puntatore pRem NORMALMENTE avanza di una posizione ad ogni ciclo (++pRem), MA quando incontra uno '{parsed_message}' ("else", ovvero !(*pRem)) avanza quanto basta per superare d'un botto l'intera serie degli '{parsed_message}' immessi da una delle chiamate a memset(), cioè di lRem caratteri. E' vero che trovi scritto lRem-1, però bisogna tenere presente che dopo essere stato "spinto in avanti" di lRem-1 posizioni, pRem viene "spinto in avanti" di un'ulteriore posizione per via del ++pRem tra le parentesi del for.

In altre parole, più schematicamente...

finche' non e' finita la stringa str
    se *pRem non è '{parsed_message}'
        copia *pRem in *pStr
        entrambi i puntatori avanzano di una posizione
    altrimenti (se *pRem e' '{parsed_message}')
        non viene copiato nulla
        pStr resta dov'e'
        pRem avanza di lRem posizioni

Secondo me è più conveniente rispetto alla soluzione con l'array di int per conservare le posizioni delle parti da eliminare, anche perché in questo modo non serve allocare/deallocare memoria, e si evita la possibilità degli errori potenzialmente correlati all'uso della memoria dinamica.

Non sono in grado di esprimere valutazioni ragionate (non ho le competenze necessarie), ma "a spanne" mi sa anche che col metodo che ho usato io si risparmiano un po' di "risorse".').

Inizialmente entrambi i puntatori combaciano con l'indirizzo d'inizio della stringa dalla quale rimuovere la sottostringa. Il ciclo procede fino a che la differenza tra il puntatore "di prelievo" e quello "di destinazione" è minore della lunghezza della stringa str, ovvero fino a che si arriva in fondo alla stringa stessa.

Il puntatore pRem NORMALMENTE avanza di una posizione ad ogni ciclo (++pRem), MA quando incontra uno 'for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

Ci son due coccodrilli... anzi, no, due puntatori che tengono traccia l'uno (pStr) dell'avanzamento del punto nel quale vengono copiati i caratteri da tenere, l'altro (pRem) dell'avanzamento del punto dal quale vengono prelevati i caratteri da copiare (tutti tranne gli '{parsed_message}').

Inizialmente entrambi i puntatori combaciano con l'indirizzo d'inizio della stringa dalla quale rimuovere la sottostringa. Il ciclo procede fino a che la differenza tra il puntatore "di prelievo" e quello "di destinazione" è minore della lunghezza della stringa str, ovvero fino a che si arriva in fondo alla stringa stessa.

Il puntatore pRem NORMALMENTE avanza di una posizione ad ogni ciclo (++pRem), MA quando incontra uno '{parsed_message}' ("else", ovvero !(*pRem)) avanza quanto basta per superare d'un botto l'intera serie degli '{parsed_message}' immessi da una delle chiamate a memset(), cioè di lRem caratteri. E' vero che trovi scritto lRem-1, però bisogna tenere presente che dopo essere stato "spinto in avanti" di lRem-1 posizioni, pRem viene "spinto in avanti" di un'ulteriore posizione per via del ++pRem tra le parentesi del for.

In altre parole, più schematicamente...

finche' non e' finita la stringa str
    se *pRem non è '{parsed_message}'
        copia *pRem in *pStr
        entrambi i puntatori avanzano di una posizione
    altrimenti (se *pRem e' '{parsed_message}')
        non viene copiato nulla
        pStr resta dov'e'
        pRem avanza di lRem posizioni

Secondo me è più conveniente rispetto alla soluzione con l'array di int per conservare le posizioni delle parti da eliminare, anche perché in questo modo non serve allocare/deallocare memoria, e si evita la possibilità degli errori potenzialmente correlati all'uso della memoria dinamica.

Non sono in grado di esprimere valutazioni ragionate (non ho le competenze necessarie), ma "a spanne" mi sa anche che col metodo che ho usato io si risparmiano un po' di "risorse".' ("else", ovvero !(*pRem)) avanza quanto basta per superare d'un botto l'intera serie degli 'for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;

Ci son due coccodrilli... anzi, no, due puntatori che tengono traccia l'uno (pStr) dell'avanzamento del punto nel quale vengono copiati i caratteri da tenere, l'altro (pRem) dell'avanzamento del punto dal quale vengono prelevati i caratteri da copiare (tutti tranne gli '{parsed_message}').

Inizialmente entrambi i puntatori combaciano con l'indirizzo d'inizio della stringa dalla quale rimuovere la sottostringa. Il ciclo procede fino a che la differenza tra il puntatore "di prelievo" e quello "di destinazione" è minore della lunghezza della stringa str, ovvero fino a che si arriva in fondo alla stringa stessa.

Il puntatore pRem NORMALMENTE avanza di una posizione ad ogni ciclo (++pRem), MA quando incontra uno '{parsed_message}' ("else", ovvero !(*pRem)) avanza quanto basta per superare d'un botto l'intera serie degli '{parsed_message}' immessi da una delle chiamate a memset(), cioè di lRem caratteri. E' vero che trovi scritto lRem-1, però bisogna tenere presente che dopo essere stato "spinto in avanti" di lRem-1 posizioni, pRem viene "spinto in avanti" di un'ulteriore posizione per via del ++pRem tra le parentesi del for.

In altre parole, più schematicamente...

finche' non e' finita la stringa str
    se *pRem non è '{parsed_message}'
        copia *pRem in *pStr
        entrambi i puntatori avanzano di una posizione
    altrimenti (se *pRem e' '{parsed_message}')
        non viene copiato nulla
        pStr resta dov'e'
        pRem avanza di lRem posizioni

Secondo me è più conveniente rispetto alla soluzione con l'array di int per conservare le posizioni delle parti da eliminare, anche perché in questo modo non serve allocare/deallocare memoria, e si evita la possibilità degli errori potenzialmente correlati all'uso della memoria dinamica.

Non sono in grado di esprimere valutazioni ragionate (non ho le competenze necessarie), ma "a spanne" mi sa anche che col metodo che ho usato io si risparmiano un po' di "risorse".' immessi da una delle chiamate a memset(), cioè di lRem caratteri. E' vero che trovi scritto lRem-1, però bisogna tenere presente che dopo essere stato "spinto in avanti" di lRem-1 posizioni, pRem viene "spinto in avanti" di un'ulteriore posizione per via del ++pRem tra le parentesi del for.

In altre parole, più schematicamente...

finche' non e' finita la stringa str
    se *pRem non è 'for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )

  if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;



Ci son due coccodrilli... anzi, no, due puntatori che tengono traccia l'uno (pStr) dell'avanzamento del punto nel quale vengono copiati i caratteri da tenere, l'altro (pRem) dell'avanzamento del punto dal quale vengono prelevati i caratteri da copiare (tutti tranne gli '{parsed_message}').



Inizialmente entrambi i puntatori combaciano con l'indirizzo d'inizio della stringa dalla quale rimuovere la sottostringa. Il ciclo procede fino a che la differenza tra il puntatore "di prelievo" e quello "di destinazione" è minore della lunghezza della stringa str, ovvero fino a che si arriva in fondo alla stringa stessa.



Il puntatore pRem NORMALMENTE avanza di una posizione ad ogni ciclo (++pRem), MA quando incontra uno '{parsed_message}' ("else", ovvero !(*pRem)) avanza quanto basta per superare d'un botto l'intera serie degli '{parsed_message}' immessi da una delle chiamate a memset(), cioè di lRem caratteri. E' vero che trovi scritto lRem-1, però bisogna tenere presente che dopo essere stato "spinto in avanti" di lRem-1 posizioni, pRem viene "spinto in avanti" di un'ulteriore posizione per via del ++pRem tra le parentesi del for.



In altre parole, più schematicamente...



finche' non e' finita la stringa str
    se *pRem non è '{parsed_message}'
        copia *pRem in *pStr
        entrambi i puntatori avanzano di una posizione
    altrimenti (se *pRem e' '{parsed_message}')
        non viene copiato nulla
        pStr resta dov'e'
        pRem avanza di lRem posizioni



Secondo me è più conveniente rispetto alla soluzione con l'array di int per conservare le posizioni delle parti da eliminare, anche perché in questo modo non serve allocare/deallocare memoria, e si evita la possibilità degli errori potenzialmente correlati all'uso della memoria dinamica.



Non sono in grado di esprimere valutazioni ragionate (non ho le competenze necessarie), ma "a spanne" mi sa anche che col metodo che ho usato io si risparmiano un po' di "risorse".'
        copia *pRem in *pStr
        entrambi i puntatori avanzano di una posizione
    altrimenti (se *pRem e' 'for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )

  if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;



Ci son due coccodrilli... anzi, no, due puntatori che tengono traccia l'uno (pStr) dell'avanzamento del punto nel quale vengono copiati i caratteri da tenere, l'altro (pRem) dell'avanzamento del punto dal quale vengono prelevati i caratteri da copiare (tutti tranne gli '{parsed_message}').



Inizialmente entrambi i puntatori combaciano con l'indirizzo d'inizio della stringa dalla quale rimuovere la sottostringa. Il ciclo procede fino a che la differenza tra il puntatore "di prelievo" e quello "di destinazione" è minore della lunghezza della stringa str, ovvero fino a che si arriva in fondo alla stringa stessa.



Il puntatore pRem NORMALMENTE avanza di una posizione ad ogni ciclo (++pRem), MA quando incontra uno '{parsed_message}' ("else", ovvero !(*pRem)) avanza quanto basta per superare d'un botto l'intera serie degli '{parsed_message}' immessi da una delle chiamate a memset(), cioè di lRem caratteri. E' vero che trovi scritto lRem-1, però bisogna tenere presente che dopo essere stato "spinto in avanti" di lRem-1 posizioni, pRem viene "spinto in avanti" di un'ulteriore posizione per via del ++pRem tra le parentesi del for.



In altre parole, più schematicamente...



finche' non e' finita la stringa str
    se *pRem non è '{parsed_message}'
        copia *pRem in *pStr
        entrambi i puntatori avanzano di una posizione
    altrimenti (se *pRem e' '{parsed_message}')
        non viene copiato nulla
        pStr resta dov'e'
        pRem avanza di lRem posizioni



Secondo me è più conveniente rispetto alla soluzione con l'array di int per conservare le posizioni delle parti da eliminare, anche perché in questo modo non serve allocare/deallocare memoria, e si evita la possibilità degli errori potenzialmente correlati all'uso della memoria dinamica.



Non sono in grado di esprimere valutazioni ragionate (non ho le competenze necessarie), ma "a spanne" mi sa anche che col metodo che ho usato io si risparmiano un po' di "risorse".')
        non viene copiato nulla
        pStr resta dov'e'
        pRem avanza di lRem posizioni

Secondo me è più conveniente rispetto alla soluzione con l'array di int per conservare le posizioni delle parti da eliminare, anche perché in questo modo non serve allocare/deallocare memoria, e si evita la possibilità degli errori potenzialmente correlati all'uso della memoria dinamica.

Non sono in grado di esprimere valutazioni ragionate (non ho le competenze necessarie), ma "a spanne" mi sa anche che col metodo che ho usato io si risparmiano un po' di "risorse".

Nemmeno io ho ancora del tutto le competenze necessarie, ma secondo me è una buona soluzione. Davvero. Grazie mille per l'ulteriore spiegazione, cercherò di integrarla nella mia soluzione !

Mi accorgo or ora che usare quel memset() è uno "spreco", nel senso che basta "segnare" con 'Mi accorgo or ora che usare quel memset() è uno "spreco", nel senso che basta "segnare" con '{parsed_message}' il solo primo carattere di ogni sottostringa da eliminare trovata. Non so quanto possa migliorare l'efficienza, però sprecare non è mai una bella cosa, come regola di vita.

#include <stdio.h>
#include <string.h>
 
//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================
 
char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );
 
        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;
 
            // in str, sostituisce con '{parsed_message}' l'inizio
            // di ogni sottostringa da eliminare
            while( pStr ) {
                *pStr = '{parsed_message}';
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }
 
            // "compatta" la stringa eliminando le sottostringhe
            // segnalate dagli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
            *pStr = '{parsed_message}'; // termina la stringa
        }
    }
 
    return str; // restituisce l'indirizzo ricevuto in str
}
 
// Esempio d'uso
 
int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}

' il solo primo carattere di ogni sottostringa da eliminare trovata. Non so quanto possa migliorare l'efficienza, però sprecare non è mai una bella cosa, come regola di vita.

#include <stdio.h>
#include <string.h>
 
//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================
 
char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );
 
        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;
 
            // in str, sostituisce con 'Mi accorgo or ora che usare quel memset() è uno "spreco", nel senso che basta "segnare" con '{parsed_message}' il solo primo carattere di ogni sottostringa da eliminare trovata. Non so quanto possa migliorare l'efficienza, però sprecare non è mai una bella cosa, come regola di vita. 



#include <stdio.h>
#include <string.h>
 
//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================
 
char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );
 
        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;
 
            // in str, sostituisce con '{parsed_message}' l'inizio
            // di ogni sottostringa da eliminare
            while( pStr ) {
                *pStr = '{parsed_message}';
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }
 
            // "compatta" la stringa eliminando le sottostringhe
            // segnalate dagli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
            *pStr = '{parsed_message}'; // termina la stringa
        }
    }
 
    return str; // restituisce l'indirizzo ricevuto in str
}
 
// Esempio d'uso
 
int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}
' l'inizio
            // di ogni sottostringa da eliminare
            while( pStr ) {
                *pStr = 'Mi accorgo or ora che usare quel memset() è uno "spreco", nel senso che basta "segnare" con '{parsed_message}' il solo primo carattere di ogni sottostringa da eliminare trovata. Non so quanto possa migliorare l'efficienza, però sprecare non è mai una bella cosa, come regola di vita. 



#include <stdio.h>
#include <string.h>
 
//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================
 
char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );
 
        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;
 
            // in str, sostituisce con '{parsed_message}' l'inizio
            // di ogni sottostringa da eliminare
            while( pStr ) {
                *pStr = '{parsed_message}';
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }
 
            // "compatta" la stringa eliminando le sottostringhe
            // segnalate dagli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
            *pStr = '{parsed_message}'; // termina la stringa
        }
    }
 
    return str; // restituisce l'indirizzo ricevuto in str
}
 
// Esempio d'uso
 
int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}
';
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }
 
            // "compatta" la stringa eliminando le sottostringhe
            // segnalate dagli 'Mi accorgo or ora che usare quel memset() è uno "spreco", nel senso che basta "segnare" con '{parsed_message}' il solo primo carattere di ogni sottostringa da eliminare trovata. Non so quanto possa migliorare l'efficienza, però sprecare non è mai una bella cosa, come regola di vita. 



#include <stdio.h>
#include <string.h>
 
//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================
 
char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );
 
        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;
 
            // in str, sostituisce con '{parsed_message}' l'inizio
            // di ogni sottostringa da eliminare
            while( pStr ) {
                *pStr = '{parsed_message}';
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }
 
            // "compatta" la stringa eliminando le sottostringhe
            // segnalate dagli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
            *pStr = '{parsed_message}'; // termina la stringa
        }
    }
 
    return str; // restituisce l'indirizzo ricevuto in str
}
 
// Esempio d'uso
 
int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}
' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
            *pStr = 'Mi accorgo or ora che usare quel memset() è uno "spreco", nel senso che basta "segnare" con '{parsed_message}' il solo primo carattere di ogni sottostringa da eliminare trovata. Non so quanto possa migliorare l'efficienza, però sprecare non è mai una bella cosa, come regola di vita. 



#include <stdio.h>
#include <string.h>
 
//==============================================================================
// Funzione strrem, "string remove"
//
//     char *strrem( char *str, const char *rem );
//
// Questa funzione si occupa di eliminare tutte le occorrenze della stringa rem
// dalla stringa str. L'eliminazione avviene "sul posto", in modo distruttivo
// (in uscita, str risulta modificata; il contenuto originale e' perso).
//
//     str     str: stringa; un puntatore a char che punta ad una stringa C
//             valida (zero terminated); dopo l'elaborazione, il contenuto della
//             stringa puo' risultare modificato senza possibilita' di recupero
//
//     rem     rem: remove; un puntatore a const char che punta ad una stringa C
//             valida (zero terminated); la stringa puntata da rem non viene mai
//             modificata
//
// Valore di ritorno: lo stesso puntatore a char passato in str.
//
// Note:
// Non avviene alcuna elaborazione se 1) str o rem sono NULL o se 2) la
// lunghezza della stringa puntata da rem supera quella della stringa puntata da
// str. Richiede l'inclusione del file string.h.
//==============================================================================
 
char *strrem( char *str, const char *rem ) {
    if( str && rem ) {
        size_t lStr = strlen( str );
        size_t lRem = strlen( rem );
 
        if( lRem <= lStr ) {
            char *pStr = strstr(str,rem);
            const char *pRem = str;
 
            // in str, sostituisce con '{parsed_message}' l'inizio
            // di ogni sottostringa da eliminare
            while( pStr ) {
                *pStr = '{parsed_message}';
                pStr += lRem;
                pStr = strstr( pStr, rem );
            }
 
            // "compatta" la stringa eliminando le sottostringhe
            // segnalate dagli '{parsed_message}' immessi in precedenza
            for( pStr=str, pRem=str; pRem-str<lStr; ++pRem )
                if( *pRem ) *pStr++ = *pRem; else pRem += lRem-1;
 
            *pStr = '{parsed_message}'; // termina la stringa
        }
    }
 
    return str; // restituisce l'indirizzo ricevuto in str
}
 
// Esempio d'uso
 
int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}
'; // termina la stringa
        }
    }
 
    return str; // restituisce l'indirizzo ricevuto in str
}
 
// Esempio d'uso
 
int main() {
    char str[] = "acacsssdstgfdfgdacacddf";
    const char rem[] = "ac"; // da sottrarre
    printf( "%s - %s", str, rem );
    printf( " = %s\n\n", strrem(str,rem) );
}

TI ringrazio tantissimo per la risposta e l'aiuto !