Por que é sizeof (string) == 32?

Qual é a sobrecarga na estrutura de string que faz com que sizeof () seja 32?

Algumas implementações std::string salvam strings muito pequenas diretamente na pilha em uma matriz char tamanho char vez de usar o armazenamento dynamic de heap. Isso permite evitar alocações de heap para muitos objects de string pequenos e melhora a localidade de referência.

Além disso, haverá um membro std::size_t para salvar o tamanho das strings e um ponteiro (potencialmente não utilizado, veja acima) para o armazenamento de heap.

std::string normalmente contém um buffer para a “otimização de string pequena” — se a string for menor que o tamanho do buffer, então nenhuma alocação de heap é necessária.

Meu palpite é:

 class vector { char type; struct Heap { char* start; char* end; char* allocatedEnd; }; struct Stack { char size; char data[27]; } union { Stack stackVersion; Heap heapVersion; } version; }; 

Mas aposto que existem centenas de maneiras de fazer isso.

É dependente da biblioteca. Você não deve confiar no tamanho de objects std::string porque é provável que ele mude em diferentes ambientes (obviamente entre diferentes fornecedores de bibliotecas padrão, mas também entre versões diferentes da mesma biblioteca).

Tenha em mente que as implementações std::string são escritas por pessoas que otimizaram para uma variedade de casos de uso, normalmente levando a duas representações internas, uma para strings curtas (buffer interno pequeno) e outra para strings longas (buffer externo alocado para heap ). A sobrecarga está associada à retenção de ambos dentro de cada object std::string .

Em g ++ 5.2 (em eg g ++ 4.9, é diferente) uma string é basicamente definida como:

 class string { char* bufferp; size_t length; union { char local_buffer[16]; size_t capacity; }; }; 

Em um computador comum, isso sum até 32 bytes (8 + 8 + 16).

A definição real é claro

 typedef basic_string string; 

mas a ideia é a mesma.

P: Por que um cachorro é amarelo? Não é necessariamente.

O tamanho de um object (an?) Std :: string depende da implementação. Acabei de verificar o MS VC ++ 2010. Ele realmente usa 32 bytes para std :: string. Há uma união de 16 bytes que contém o texto da seqüência de caracteres, se ele couber ou um ponteiro para o armazenamento de heap para seqüências de caracteres mais longas. Se os implementadores tivessem escolhido manter sequências de 18 bytes no object de seqüência de caracteres em vez de no heap, o tamanho seria 34 bytes. Os outros 16 bytes compreendem sobrecarga, contendo coisas como o comprimento da string e a quantidade de memory atualmente alocada para a string.

Uma implementação diferente pode sempre alocar memory do heap. Tal implementação, sem dúvida, exigiria menos memory para o object string.