Esiste uno strcmp sicuro?

Question

Ho fatto una funzione come questa:

bool IsSameString(char* p1, char* p2) 
{ 
    return 0 == strcmp(p1, p2); 
} 

Il problema è che a volte, per errore, gli argomenti vengono passati che non sono stringhe (che significa che p1 o p2 non termina con un carattere nullo). Quindi, strcmp continua a eseguire il confronto finché non raggiunge la memoria non accessibile e si arresta in modo anomalo. Esiste una versione sicura di strcmp? O posso dire se p1 (e p2) è una stringa o non in modo sicuro?

Answer 1

No, non esiste un modo (standard) per stabilire se uno char * punta effettivamente alla memoria valida.

Nella propria situazione, è preferibile utilizzare std::string anziché char * s per tutte le stringhe, insieme all'operatore sovraccaricato ==. Se lo fai, il compilatore impone la sicurezza del tipo.

EDIT: Come per i commenti qui sotto se vi trovate in una situazione in cui a volte si passa char * s che possono o non possono essere stringhe valide per funzioni che prevedono stringhe null-terminated allora c'è qualcosa di fondamentalmente sbagliato con il tuo approccio , quindi in pratica la risposta @ janm in basso.

Answer 2

Non c'è cura per questo che è portatile. La convenzione afferma che c'è un carattere in più che contiene un carattere null che appartiene allo stesso blocco di memoria assegnato correttamente della stringa stessa. O si segue questa convenzione e si verifica qualsiasi comportamento fine o indefinito.

Se si conosce la lunghezza della stringa confrontata, è possibile utilizzare strncmp() ma non sarà di aiuto se la stringa passata al codice è effettivamente più breve della stringa confrontata.

Answer 3

In alcuni casi std::strncmp possibile risolvere il problema:

int strncmp (const char * str1, const char * str2, size_t num); 

Esso mette a confronto fino a num caratteri della stringa str1 C a quelli della stringa str2 C.

---

Inoltre, uno sguardo, quello che la divisione statunitense DHS National Cyber ​​Security recommends su questa materia:

Assicurarsi che le stringhe sono nulli terminati prima di passare in strcmp. Questo può essere fatto mettendo sempre un \ 0 nell'ultimo byte assegnato del buffer.

char str1[] ="something"; 
char str2[] = "another thing"; 
/* In this case we know strings are null terminated. Pretend we don't. */ 
str1[sizeof(str1)-1] = '\0'; 
str2[sizeof(str2)-1] = '\0'; 
/* Now the following is safe. */ 
if (strcmp(str1, str2)) { /* do something */ } else { /* do something else */ } 

Answer 4

Si può mettere un limite massimo al numero di caratteri da confrontare utilizzando la funzione strncmp.

Answer 5

è possibile utilizzare strncmp, ma se possibile uso std :: string per evitare molti problemi :)

Answer 6

Tu non scrive, quale piattaforma che si sta utilizzando.Windows ha le seguenti funzioni:

• IsBadStringPtr
• IsBadReadPtr
• IsBadWritePtr

IsBadStringPtr potrebbe essere quello che stai cercando, se si utilizza Windows.

Answer 7

Non c'è una risposta migliore a questo, come non è possibile verificare il char * è una stringa. L'unica soluzione è creare un tipo e usarlo come stringa per esempio str :: string o crearne uno proprio se si desidera qualcosa di più leggero. ie

struct MyString 
    { 
    MyString() : str(0), len(0) {} 
    MyString(char* x) { len = strlen(x); str = strdup(x); } 
    ⁓MyString() { if(str) free(str); } 
    char* str; 
    size_t len; 
    }; 

bool IsSameString(MyString& p1, MyString& p2) 
    { 
    return 0 == strcmp(p1.str, p2.str); 
    } 


MyString str1("test"); 
MyString str2("test"); 

if(IsSameString(str1, str2) {} 

Answer 8

Se si passano stringhe a strcmp() che non sono terminate con null si è già perso. Il fatto che tu abbia una stringa che non è terminata con null (ma dovrebbe essere) indica che hai problemi più profondi nel tuo codice. Non è possibile modificare strcmp() per risolvere questo problema in modo sicuro.

Si dovrebbe scrivere il codice in modo che non potrà mai accadere. Inizia usando la classe string. Ai confini in cui prendi i dati nel tuo codice, devi assicurarti di trattare i casi eccezionali; se ottieni troppi dati devi fare la cosa giusta. Ciò non significa esaurire la fine del tuo buffer. Se è necessario eseguire I/O in un buffer in stile C, utilizzare le funzioni in cui si specifica la lunghezza del buffer e rilevare e trattare i casi in cui il buffer non è sufficientemente grande in quel punto.