[C++] Funzione cancella stringa

[mistergks]

Ho provato a fare questo esercizio:
ho due stringhe (come array di char) A={"CIAO"}; B={"AI"}.
Devo eliminare in A ogni lettera presente in B e mettere la nuova parola in un nuovo array di char C.
Ho pensato di controllare le lettere uguali con due for e di inserire asterischi al posto delle lettere uguali in A. poi successivamente vado a mettere nell array C solo le lettere diverse da asterisco.
Dovrebbe stampare la stringa CO invece stampa COAI. cosa non va?
CODICE

#include <iostream>
using namespace std;

void cancella(char A[], char B[], char C[]);

int main(){
    char A[]={"CIAO"};
    char B[]={"AI"};
    char C[]={" "};
    
    cancella(A,B,C);
    for(int i=0; i<strlen(C); i++)
    cout<<C[i]<<endl;
    
system("pause");
return 0;
}

void cancella(char A[], char B[], char C[]){
     int n=0;
     for(int i=0; i<strlen(A); i++){
             for(int j=0; j<strlen(B); j++){
                     if(A[i]==B[j])
                     A[i]='*';
                     
                     }
             }
     for(int k=0; k<strlen(A); k++){
             if(A[k]!='*')
             C[n++]=A[k];
             }
}

[vendettaaaaa]

Originariamente inviato da mistergks

Ho provato a fare questo esercizio:
ho due stringhe (come array di char) A={"CIAO"}; B={"AI"}.
Devo eliminare in A ogni lettera presente in B e mettere la nuova parola in un nuovo array di char C.
Ho pensato di controllare le lettere uguali con due for e di inserire asterischi al posto delle lettere uguali in A. poi successivamente vado a mettere nell array C solo le lettere diverse da asterisco.
Dovrebbe stampare la stringa CO invece stampa COAI. cosa non va?
CODICE

#include <iostream>
using namespace std;

void cancella(char A[], char B[], char C[]);

int main(){
    char A[]={"CIAO"};
    char B[]={"AI"};
    char C[]={" "};
    
    cancella(A,B,C);
    for(int i=0; i<strlen(C); i++)
    cout<<C[i]<<endl;
    
system("pause");
return 0;
}

void cancella(char A[], char B[], char C[]){
     int n=0;
     for(int i=0; i<strlen(A); i++){
             for(int j=0; j<strlen(B); j++){
                     if(A[i]==B[j])
                     A[i]='*';
                     
                     }
             }
     for(int k=0; k<strlen(A); k++){
             if(A[k]!='*')
             C[n++]=A[k];
             }
}

Gli array non sanno che dimensione hanno, e per di più ridimensionarli è un casino. Non aumentano la loro dimensione da soli se gli dai un indice più grande del loro range. Quindi quando scrivi C[n++], quando n > 0, chissà cosa succede in memoria. Io ho questo output con strlen(C) == 14:

C
O
[
[
[
[
[
[
[
[
[
[
A
I

Quindi direi che il minimo è dimensionare, nel main, C uguale ad A:

char A[100] = {"CIAO"};
char C[100];

Non so bene come fare il ridimensionamento dinamico con malloc() perchè gli array praticamente non li ho mai usati, meglio usare vector che sono ridimensionabili e hanno un sacco di funzioni.
C'è un altro "errore":

C[n++] = A[k];

è sbagliato concettualmente perchè il risultato è equivalente a:

C[n] = A[k];
++n;

ma rischi di sbagliare in quanto l'ordine di priorità rispetto ad altri operatori potrebbe non essere quello che ti aspetti. Inoltre se leggi 2 volte in una riga il valore di una variabile che in quella stessa riga viene scritta il risultato è indefinito (così dice il creatore del C++): espressioni tipo

(++i) + (++i)

sono indefinite. Il codice funzionante è questo:

#include <iostream>

using namespace std;

void cancella(char A[], char B[], char C[]);

int main() {
	char A[100] = {"CIAO"};
	char B[100] = {"AI"};
	char C[100] = {""};
    
	cancella(A,B,C);
	for(int i = 0; i < strlen(A); ++i) cout << A[i];
	cout << "\nstrlen(A) = " << strlen(A) << endl;
	for(int i = 0; i < strlen(B); ++i) cout << B[i];
	cout << "\nstrlen(B) = " << strlen(A) << endl;
	for(int i = 0; i < strlen(C); ++i) cout << C[i];
	cout << "\nstrlen(C) = " << strlen(C) << endl;

	system("pause");
	return 0;

	int i = 1;
	int j = ++i + i++;
	cout << endl << endl << j << endl << endl;
}

void cancella(char A[], char B[], char C[]) {
	int n = 0;
	for (int i = 0; i < strlen(A); ++i) {
		for (int j = 0; j < strlen(B); ++j) {
				if (A[i] == B[j]) A[i] = '*';
                                break;
		}
	}
    
	for (int k = 0; k < strlen(A); ++k) {
		if (A[k] != '*') {
			C[n] = A[k];
			++n;
		}
	}
}

[mistergks]

Originariamente inviato da vendettaaaaa

Gli array non sanno che dimensione hanno, e per di più ridimensionarli è un casino. Non aumentano la loro dimensione da soli se gli dai un indice più grande del loro range. Quindi quando scrivi C[n++], quando n > 0, chissà cosa succede in memoria. Io ho questo output con strlen(C) == 14:

C
O
[
[
[
[
[
[
[
[
[
[
A
I

Quindi direi che il minimo è dimensionare, nel main, C uguale ad A:

char A[100] = {"CIAO"};
char C[100];

Non so bene come fare il ridimensionamento dinamico con malloc() perchè gli array praticamente non li ho mai usati, meglio usare vector che sono ridimensionabili e hanno un sacco di funzioni.
C'è un altro "errore":

C[n++] = A[k];

è sbagliato concettualmente perchè il risultato è equivalente a:

C[n] = A[k];
++n;

ma rischi di sbagliare in quanto l'ordine di priorità rispetto ad altri operatori potrebbe non essere quello che ti aspetti. Inoltre se leggi 2 volte in una riga il valore di una variabile che in quella stessa riga viene scritta il risultato è indefinito (così dice il creatore del C++): espressioni tipo

(++i) + (++i)

sono indefinite. Il codice funzionante è questo:

#include <iostream>

using namespace std;

void cancella(char A[], char B[], char C[]);

int main() {
	char A[100] = {"CIAO"};
	char B[100] = {"AI"};
	char C[100] = {""};
    
	cancella(A,B,C);
	for(int i = 0; i < strlen(A); ++i) cout << A[i];
	cout << "\nstrlen(A) = " << strlen(A) << endl;
	for(int i = 0; i < strlen(B); ++i) cout << B[i];
	cout << "\nstrlen(B) = " << strlen(A) << endl;
	for(int i = 0; i < strlen(C); ++i) cout << C[i];
	cout << "\nstrlen(C) = " << strlen(C) << endl;

	system("pause");
	return 0;

	int i = 1;
	int j = ++i + i++;
	cout << endl << endl << j << endl << endl;
}

void cancella(char A[], char B[], char C[]) {
	int n = 0;
	for (int i = 0; i < strlen(A); ++i) {
		for (int j = 0; j < strlen(B); ++j) {
				if (A[i] == B[j]) A[i] = '*';
                                break;
		}
	}
    
	for (int k = 0; k < strlen(A); ++k) {
		if (A[k] != '*') {
			C[n] = A[k];
			++n;
		}
	}
}

a me il tuo codice stampa:

CI*O
strlen(A)=4;
AI
strlen(B)=4
CIO
strlen(C)=3

non dovrebbe stamparmi la stringa CO alla fine?!toglie solo la A?

[vendettaaaaa]

Non mi ricordo perchè ma dopo aver testato il codice ho aggiunto un break nel ciclo for che cancella le lettere di A, è quello il problema.
Ora ricordo, il break l'ho aggiunto qui direttamente nel post ma andrebbe nel blocco if che sta nel blocco for (j = 0...):

void cancella(char A[], char B[], char C[]) {
	int n = 0;
	for (int i = 0; i < strlen(A); ++i) {
		for (int j = 0; j < strlen(B); ++j) {
			if (A[i] == B[j]) {
				A[i] = '*';
				break;
			}
		}
	}

Così se la lettera di A viene trovata in B, viene cancellata e viene interrotta la scansione di B per risparmiare preziosissimi cicli di clock

Alternativamente si può fare così:

void cancella(char A[], char B[], char C[]) {
	int n = 0;
	for (int j = 0; j < strlen(B); ++j) {
		for (int i = 0; i < strlen(A); ++i) {
			if (B[j] == A[i]) A[i] = '*';
		}
	}

Che mi pare meglio nel caso A contenga lettere ripetute (prova con "CIAAAAAO").