Ces deux chaînes de tailles différentes doivent-elles renvoyer 0 (égal) avec strcmp?

Question

J'ai deux classes qui vont créer un cstring dynamiquement alloué (null terminé) de taille n sur un objet de cette classe en cours de création. Dans une classe, j'ai une fonction de membre surchargeant l'opérateur d'équivalence, et dans l'autre classe, j'ai une fonction non-membre surchargeant l'opérateur d'équivalence. J'utilise strcmp pour comparer deux chaînes de chaque type de classe, et peu importe ce que j'initialise le tableau, il retourne toujours vrai.

int main() { 

    CSTR cstr(5); 
    CSTR cstr2(6); 

    if (cstr == cstr2) 
     cout << "Equal"; //<< Always returns true 
    else 
     cout << "False"; 

    cout << "\n\n"; 

    CSTR2 cstr2_1(5); 
    CSTR2 cstr2_2(6); 

    if (cstr2_1 == cstr2_2) 
     cout << "Equal"; //<< Always returns true 
    else 
     cout << "False"; 
    return 0; 
} 

============================== 

class CSTR { 
    public: 
     CSTR(); 
     CSTR(unsigned int n); 
     ~CSTR(); 


     bool operator ==(const CSTR & rhs); 
    private: 
     unsigned int size; 
     char *elems; 
}; 

============================ 

CSTR::CSTR() { 

    size = 0; 
    elems = new char [0]; 
} 

CSTR::CSTR(unsigned int n) { 
    if (n > 0) { 
     size = n; 
     elems = new char [size]; 
} 
    else { 
     size = 0; 
     elems = new char [0]; 
    } 
} 

CSTR::~CSTR() { 

    delete [] elems; 
} 

bool CSTR::operator ==(const CSTR & rhs) { //<< Always returns true 

    return (strcmp(elems, rhs.elems) == 0); 
} 

=========================================== 

class CSTR2 { 
    public: 
     CSTR2(); 
     CSTR2(unsigned int n); 
     ~CSTR2(); 

     char * getCstrPtr() const; 
    private: 
     unsigned int size; 
     char *elems; 
}; 

bool operator ==(const CSTR2 & CSTR2_1, const CSTR2 & CSTR2_2); 

======================================== 

CSTR2::CSTR2() { 

    size = 0; 
    elems = new char [0]; 
} 

CSTR2::CSTR2(unsigned int n) { 

    if (n > 0) { 
     size = n; 
     elems = new char [size]; 
    } 
    else { 
     size = 0; 
     elems = new char [0]; 
    } 
} 

CSTR2::~CSTR2() { 

    delete [] elems; 
} 


char * CSTR2::getCstrPtr() const { 

    return elems; 
} 


bool operator ==(const CSTR2 & CSTR2_1, const CSTR2 & CSTR2_2) { //<< Always returns true 

    return (strcmp(CSTR2_1.getCstrPtr(), CSTR2_2.getCstrPtr()) == 0); 
} 

Answer 1

Vous n'avez pas initialisées le contenu de ces tampons vous new ed up. Ils peuvent contenir quoi que ce soit. Si les deux buffers que vous avez alloués ont tous les deux commencé par '\0', alors strcmp diraient en effet qu'ils sont égaux (puisqu'ils sont tous les deux considérés comme des chaînes de longueur nulle).

Aussi, je suis d'accord avec tout dans le commentaire de Praetorian, en particulier sur la Règle de Trois.