Dúvida Simples, array de Strings C++ [RESOLVIDO]

Eu acho sempre bom evitar amarrar o nome do tipo se você puder. E no caso acima você pode.

std::string List2[sizeof List1 / sizeof list1[0]]; 

E outra coisa: esse array não será vazio, como você colocou no seu comentário, pois nunca existem arrays vazios em C ou C++. Por sua natureza fixa, arrays nativos são amarrados em memória desde o início de sua vida (o momento da declaração) até o final dela (seja o final do bloco ou o do programa). Você pode até não conhecer ou não estar interessado nos valores iniciais, mas o número de elementos nunca muda, e todos eles têm alguma coisa guardada.

No seu caso, List2 é um array com três elementos. Como o tipo std::string possui um construtor default (i.e. que não recebe argumentos) que cria uma string vazia, tal construtor é invocado para cada elemento no momento em que a declaração é processada. Você terá, portanto, um array com três elementos, e cada um desses elementos será uma string vazia.

NOTA: std::string usa alocação dinâmica para armazenar a string que você eventualmente colocar em cada objeto criado. Quando você declara um array de std::strings, você só vai reservar espaço na memória para guardar os campos de controle da classe std::string (que certamente incluem um ponteiro para a região que vier a ser dinamicamente alocada para conter os dados da string). Assim sendo, os três arrays abaixo vão produzir o mesmo valor se você aplicar sizeof sobre cada um deles, embora sejam completamente diferentes os valores de resposta da chamada de std::string::length() em cada um dos seus elementos.

std::string

    a1[3],

    a2[3]={"abc", "def", "ghi"},

    a3[3]={"Todo o texto da Bíblia", "Todo o texto da Encyclopaedia Britannica", "Todos os textos da Internet concatenados"}

; 

O que você quer, então, é std::vector. Não existe nada parecido com isso usando arrays nativos em C++.

NOTA: Em C, existe desde o padrão de 1999 uma espécie array de tamanho variável (variable-length array, ou VLA), mas o “tamanho variável” significa apenas que o valor usado no momento da declaração pode vir de uma variável, não que o tamanho vai poder ser mudado após a declaração, além de outras restrições que o tornam menos atraente do que no princípio poderia parecer. VLAs no estilo do C nunca foram adotados em C++, e tudo faz crer que nunca serão. O próprio C, aliás, tornou VLAs uma parte opcional da implementação da linguagem desde o padrão de 2011, o que torna o recurso ainda menos atrativo.



Não como array nativo. Use std::vector.



O custo adicional, em tempo de execução, de usar std::vector, comparado a arraus nativos, tende a ser baixo; quase zero — a não ser que você fique o tempo todo provocando realocações ou inserções e remoções de elementos em posições que não ao final do vetor. Se você considerar que operações de alteração inclusão e remoção e realocações nem sequer existem em arrays nativos, a comparação nem ao menos faz muito sentido.

Você pode reduzir a quantidade de realocações se você tiver uma ideia do tamanho que o vetor pode vir a ter, mesmo que o crie inicialmente vazio.

std::vector<int> vi;  // vi.size()==0;  vi.capacity()==0

vi.push_back(1);  // Realocação: vi.size()==1; vi.capacity()==1

vi.push_back(2);  // Outra realocação: vi.size()==2; vi.capacity()==2

vi.reserve(100);  // Realocação programada: vi.size()==2; vi.capacity()==100

for(int i=0; i<100; i++)

    vi.push_back(i);  // As primeiras 98 iterações não vão causar realocação, pois vi.size() será <= vi.capacity().  As duas últimas, vão causá-la. 

... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)