Quais são as formas de otimizar o trabalho com…

Uso de std::string_view para passar strings sem copiar os dados.
Aplicação de algoritmos de <string> e <algorithm> (por exemplo, find, search) em vez de iterar manualmente.
Reserva prévia de memória com reserve para reduzir o número de realocações ao expandir a string.
Uso de um pequeno buffer de string (Small String Optimization - SSO) em std::string (se suportado pelo compilador).
Para concatenar rapidamente muitas strings, usar std::stringstream ou adicionar elemento por elemento a uma string resultante, reservando espaço previamente.
Uso de bibliotecas específicas para trabalhar com strings, otimizadas para tarefas concretas (por exemplo, expressões regulares).
Armazenamento de strings em memória estática ou em um pool para evitar alocações dinâmicas com strings constantes.
Uso de funções de baixo nível em estilo C (memcpy, memmove) para copiar grandes volumes de dados, se for seguro e justificado.

Exemplo de uso de std::string_view:

#include <string>
#include <string_view>
#include <iostream>

void print_string(std::string_view sv) {
    std::cout << sv << std::endl;
}

int main() {
    std::string s = "Hello, world!";
    print_string(s); // Sem cópia

    const char* c_str = "Outra string";
    print_string(c_str); // Também sem cópia

    return 0;
}

Exemplo de uso de reserve:

#include <string>
#include <iostream>

int main() {
    std::string s;
    s.reserve(100); // Reservar espaço antecipadamente
    for (int i = 0; i < 100; ++i) {
        s += 'a'; // Adicionar caracteres, minimizando realocações
    }
    std::cout << "Tamanho: " << s.size() << ", Capacidade: " << s.capacity() << std::endl;
    return 0;
}

Comparação de concatenação:

#include <string>
#include <sstream>
#include <iostream>
#include <chrono>

int main() {
    const int count = 1000;
    std::string chunk = "abc";

    // Concatenação via operador +=
    auto start1 = std::chrono::high_resolution_clock::now();
    std::string result1;
    result1.reserve(count * chunk.size()); // Otimização com reserva
    for (int i = 0; i < count; ++i) {
        result1 += chunk;
    }
    auto end1 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed1 = end1 - start1;
    std::cout << "Operador += (com reserve): " << elapsed1.count() << " s" << std::endl;

    // Concatenação via stringstream
    auto start2 = std::chrono::high_resolution_clock::now();
    std::stringstream ss;
    for (int i = 0; i < count; ++i) {
        ss << chunk;
    }
    std::string result2 = ss.str();
    auto end2 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed2 = end2 - start2;
    std::cout << "stringstream: " << elapsed2.count() << " s" << std::endl;

    return 0;
}

(Nota: A performance destes métodos pode variar dependendo do compilador e da biblioteca padrão).

Quais são as formas de otimizar o trabalho com strings em C++?