Verificare se i letterali di stringa uguale sono memorizzati allo stesso indirizzo

Question

Sto sviluppando una libreria (C++) che utilizza contenitori non ordinati. Questi richiedono un hasher (di solito una specializzazione della struttura modello std::hash) per i tipi di elementi che memorizzano. Nel mio caso, quegli elementi sono classi che racchiudono stringhe letterali, simili a conststr dell'esempio allo the bottom of this page. STL offre una specializzazione per i puntatori char costanti, che, tuttavia, calcola solo puntatori, come spiegato here, in the 'Notes' section:

Non c'è specializzazione per stringhe C. std::hash<const char*> produce un hash del valore del puntatore (l'indirizzo di memoria), esso non esamina il contenuto di alcun array di caratteri.

Anche se questo è molto veloce (o almeno così credo), non è garantito dalla norma se diversi letterali uguali stringa sono memorizzati nello stesso indirizzo C++, come spiegato in this question. Se non lo sono, la prima condizione di hashers non sarebbe soddisfatto:

Per due parametri k1 e k2 che sono uguali, std::hash<Key>()(k1) == std::hash<Key>()(k2)

desidero calcolare selettivamente l'hash utilizzando la fornito specializzazione, se la garanzia di cui sopra è data, o qualche altro algoritmo in caso contrario. Sebbene ricorrere alla richiesta di coloro che includono le mie intestazioni o di costruire la mia libreria per definire una particolare macro sia fattibile, una implementazione definita sarebbe preferibile.

C'è qualche macro, in qualsiasi implementazione C++, ma principalmente g ++ e clang, la cui definizione garantisce che diversi valori letterali di stringa uguale siano memorizzati nello stesso indirizzo?

Un esempio:

#ifdef __GXX_SAME_STRING_LITERALS_SAME_ADDRESS__ 
const char str1[] = "abc"; 
const char str2[] = "abc"; 
assert(str1 == str2); 
#endif 

Answer 1

Esiste una macro, in qualsiasi implementazione C++, ma soprattutto g ++ e clang, le cui garanzie definizione che diversi letterali uguali stringa vengono memorizzati allo stesso indirizzo?

• gcc ha la -fmerge-constants option (questo non è garanzia):

tentativo unire costanti identici (costanti stringa e costanti a virgola mobile) attraverso compilazione unità.

Questa opzione è l'impostazione predefinita per la compilazione ottimizzata se l'assemblatore e il linker lo supportano. Utilizzare le costanti -fno-merge per inibire questo comportamento.

Abilitato ai livelli -O, -O2, -O3, -Os.

• Visual Studio ha String Pooling (/GF opzione "Elimina stringhe duplicate")

String messa in comune permette che erano inteso come più puntatori a buffer multipli per essere molteplici puntatori a un singolo buffer. Nel seguente codice, s e t sono inizializzati con la stessa stringa. String pooling li induce a puntare alla stessa memoria:

char *s = "This is a character buffer"; 
char *t = "This is a character buffer"; 

Nota: anche se MSDN utilizza char* stringhe letterali, const char* dovrebbe essere usato

• clang ha a quanto pare anche la possibilità -fmerge-constants, ma Non riesco a trovare molto a riguardo, tranne nella sezione --help, quindi non sono sicuro se sia davvero l'equivalente di quello di gcc:

Vieta fusione delle costanti

---

Comunque, come letterali stringa sono immagazzinate dipende dall'implementazione (molti non memorizzarli nella porzione di sola lettura del programma).

Invece di costruire la vostra libreria su possibili hack implementazione-dipendente, posso solo suggerire l'utilizzo di std::string invece di stringhe in stile C: si comporteranno esattamente come ci si aspetta.

È possibile costruire il vostro std::string sul posto nei vostri contenitori con i emplace() metodi:

std::unordered_set<std::string> my_set; 
    my_set.emplace("Hello"); 

Answer 2

Sebbene C++ non sembra consentire qualsiasi modo che funziona con le stringhe, v'è una brutta ma un po 'praticabile aggirare il problema se non ti dispiace riscrivere i tuoi letterali stringa come sequenze di caratteri.

template <typename T, T...values> 
struct static_array { 
    static constexpr T array[sizeof...(values)] { values... }; 
}; 

template <typename T, T...values> 
constexpr T static_array<T, values...>::array[]; 

template <char...values> 
using str = static_array<char, values..., '\0'>; 

int main() { 
    return str<'a','b','c'>::array != str<'a','b','c'>::array; 
} 

Questo è necessario per restituire zero. Il compilatore deve garantire che anche se più unità di traduzione istanziano str<'a','b','c'>, queste definizioni vengono unite e si finisce con un'unica matrice.

Tuttavia, è necessario assicurarsi di non mescolare questo valore con stringhe letterali. Qualsiasi stringa letterale è garantita non per confrontare uguale a qualsiasi matrice di istanze di modello.