Eu ouvi algumas pessoas expressando preocupações sobre o operador "+" em std :: string e várias soluções alternativas para acelerar a concatenação. Algum desses é realmente necessário? Em caso afirmativo, qual é a melhor maneira de concatenar strings em C ++?

O trabalho extra provavelmente não vale a pena, a menos que você realmente precise de eficiência. Você provavelmente terá uma eficiência muito melhor simplesmente usando operator + = em vez disso.

Agora, após esse aviso, vou responder sua pergunta real ...

A eficiência da classe de string STL depende da implementação de STL que você está usando.

Você pode garantir eficiência e ter maior controle fazendo a concatenação manualmente por meio de c funções integradas.

Por que operator + não é eficiente:

Dê uma olhada nesta interface:

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)

Você pode ver que um novo objeto é retornado após cada +. Isso significa que um novo buffer é usado a cada vez. Se você estiver fazendo uma tonelada de operações extras +, isso não será eficiente.

Por que você pode torná-lo mais eficiente:

• Você está garantindo eficiência em vez de confiar em um delegado para fazer isso de forma eficiente para você
• a classe std :: string não sabe nada sobre o tamanho máximo de sua string, nem com que freqüência você estará concatenando com ela. Você pode ter esse conhecimento e fazer coisas com base nessas informações. Isso levará a menos realocações.
• Você controlará os buffers manualmente para ter certeza de que não copiará a string inteira em novos buffers quando não quiser que isso aconteça.
• Você pode usar a pilha para seus buffers em vez do heap, que é muito mais eficiente.
• O operador string + criará um novo objeto string e o retornará usando um novo buffer.

Considerações para implementação:

• Acompanhe o comprimento da corda.
• Mantenha um ponteiro para o final da string e o início, ou apenas o início e use o início + o comprimento como um deslocamento para encontrar o final da string.
• Certifique-se de que o buffer em que você está armazenando sua string seja grande o suficiente para que você não precise realocar os dados
• Use strcpy em vez de strcat para que você não precise iterar sobre o comprimento da string para encontrar o final dela.

Estrutura de dados da corda:

Se você precisa de concatenações realmente rápidas, considere o uso de uma estrutura de dados de corda .

Reserve seu espaço final antes e, em seguida, use o método append com um buffer. Por exemplo, digamos que você espera que o comprimento final da string seja de 1 milhão de caracteres:

std::string s;
s.reserve(1000000);

while (whatever)
{
  s.append(buf,len);
}

Eu não me preocuparia com isso. Se você fizer isso em um loop, as strings sempre pré-alocarão a memória para minimizar as realocações - apenas use operator+=nesse caso. E se você fizer manualmente, algo assim ou mais

a + " : " + c

Então está criando temporários - mesmo se o compilador pudesse eliminar algumas cópias de valor de retorno. Isso ocorre porque em um chamado sucessivamente, operator+ele não sabe se o parâmetro de referência faz referência a um objeto nomeado ou a um temporário retornado de uma sub operator+invocação. Prefiro não me preocupar com isso antes de não ter feito o perfil primeiro. Mas vamos dar um exemplo para mostrar isso. Primeiro, introduzimos parênteses para tornar a ligação clara. Eu coloco os argumentos diretamente após a declaração da função que é usada para maior clareza. Abaixo disso, mostro qual é a expressão resultante:

((a + " : ") + c) 
calls string operator+(string const&, char const*)(a, " : ")
  => (tmp1 + c)

Agora, nessa adição, tmp1é o que foi retornado pela primeira chamada ao operador + com os argumentos mostrados. Assumimos que o compilador é realmente inteligente e otimiza a cópia do valor de retorno. Portanto, terminamos com uma nova string que contém a concatenação de ae " : ". Agora, isso acontece:

(tmp1 + c)
calls string operator+(string const&, string const&)(tmp1, c)
  => tmp2 == <end result>

Compare isso com o seguinte:

std::string f = "hello";
(f + c)
calls string operator+(string const&, string const&)(f, c)
  => tmp1 == <end result>

Ele está usando a mesma função para uma string temporária e para uma string nomeada! Portanto, o compilador precisa copiar o argumento em uma nova string e anexar a ela e retorná-la do corpo de operator+. Não pode tirar a memória de um temporário e anexar a isso. Quanto maior a expressão, mais cópias de strings precisam ser feitas.

Em seguida, o Visual Studio e o GCC oferecerão suporte à semântica de movimentação de c ++ 1x (complementando a semântica de cópia ) e referências rvalue como uma adição experimental. Isso permite descobrir se o parâmetro faz referência a um temporário ou não. Isso tornará essas adições incrivelmente rápidas, já que todos os itens acima acabarão em um "add-pipeline" sem cópias.

Se for um gargalo, você ainda pode

 std::string(a).append(" : ").append(c) ...

As appendchamadas acrescentam o argumento a *thise, em seguida, retornam uma referência a si mesmas. Portanto, nenhuma cópia de temporários é feita lá. Ou, alternativamente, o operator+=pode ser usado, mas você precisaria de parênteses feios para fixar a precedência.

Para a maioria dos aplicativos, isso simplesmente não importa. Apenas escreva seu código, felizmente sem saber como exatamente o operador + funciona, e só resolva o problema com suas próprias mãos se isso se tornar um aparente gargalo.

Ao contrário do .NET System.Strings, std :: strings do C ++ são mutáveis ​​e, portanto, podem ser construídas por meio de concatenação simples tão rápido quanto por meio de outros métodos.

talvez std :: stringstream em vez disso?

Mas eu concordo com o sentimento de que você provavelmente deve apenas mantê-lo sustentável e compreensível e então criar um perfil para ver se você realmente está tendo problemas.

No Imperfect C ++ , Matthew Wilson apresenta um concatenador de string dinâmico que pré-calcula o comprimento da string final para ter apenas uma alocação antes de concatenar todas as partes. Também podemos implementar um concatenador estático brincando com modelos de expressão .

Esse tipo de ideia foi implementado na implementação STLport std :: string - que não está em conformidade com o padrão por causa deste hack preciso.

std::string operator+aloca uma nova string e sempre copia as duas strings de operandos. repita muitas vezes e fica caro, O (n).

std::string appende, operator+=por outro lado, aumente a capacidade em 50% sempre que a corda precisar crescer. O que reduz significativamente o número de alocações de memória e operações de cópia, O (log n).

Para cordas pequenas, isso não importa. Se você tiver strings grandes, é melhor armazená-las como estão em vetor ou em alguma outra coleção como partes. E adapte seu algoritmo para trabalhar com esse conjunto de dados em vez de uma grande string.

Eu prefiro std :: ostringstream para concatenação complexa.

Como a maioria das coisas, é mais fácil não fazer algo do que fazer.

Se você deseja gerar strings grandes para uma GUI, pode ser que o que quer que você esteja produzindo possa lidar com as strings em partes melhor do que em uma string grande (por exemplo, concatenando texto em um editor de texto - geralmente eles mantêm as linhas separadas estruturas).

Se você deseja enviar para um arquivo, transmita os dados em vez de criar uma string grande e gerá-la.

Nunca achei a necessidade de tornar a concatenação mais rápida necessária se removesse a concatenação desnecessária do código lento.

Provavelmente melhor desempenho se você pré-alocar (reservar) espaço na string resultante.

template<typename... Args>
std::string concat(Args const&... args)
{
    size_t len = 0;
    for (auto s : {args...})  len += strlen(s);

    std::string result;
    result.reserve(len);    // <--- preallocate result
    for (auto s : {args...})  result += s;
    return result;
}

Uso:

std::string merged = concat("This ", "is ", "a ", "test!");

Um array simples de caracteres, encapsulado em uma classe que controla o tamanho do array e o número de bytes alocados é o mais rápido.

O truque é fazer apenas uma grande alocação no início.

em

https://github.com/pedro-vicente/table-string

Benchmarks

Para Visual Studio 2015, compilação de depuração x86, melhoria substancial em relação a C ++ std :: string.

| API                   | Seconds           
| ----------------------|----| 
| SDS                   | 19 |  
| std::string           | 11 |  
| std::string (reserve) | 9  |  
| table_str_t           | 1  |  

Você pode tentar este com reservas de memória para cada item:

namespace {
template<class C>
constexpr auto size(const C& c) -> decltype(c.size()) {
  return static_cast<std::size_t>(c.size());
}

constexpr std::size_t size(const char* string) {
  std::size_t size = 0;
  while (*(string + size) != '\0') {
    ++size;
  }
  return size;
}

template<class T, std::size_t N>
constexpr std::size_t size(const T (&)[N]) noexcept {
  return N;
}
}

template<typename... Args>
std::string concatStrings(Args&&... args) {
  auto s = (size(args) + ...);
  std::string result;
  result.reserve(s);
  return (result.append(std::forward<Args>(args)), ...);
}