Ir para o conteúdo

Última atualização：2026-10-12

Análise aprofundada do STL string

Quando usamos C++, conhecemos bem os fundamentos da biblioteca , especialmente a std::string usada para criar strings em C++. Isso é, sem dúvida, uma melhoria em relação às antigas "strings" de estilo C (que usam arrays de caracteres terminados em caractere nulo). No entanto, a biblioteca padrão de C++ introduziu no C++17 e no C++20 componentes ainda mais úteis, que podem ajudar você a escrever código mais eficiente.

No cabeçalho , a classe std::basic_string é uma classe de template que oferece especializações para vários tipos de string, incluindo a std::string para strings comuns (ou seja, std::basic_string) e a std::wstring para strings largas (ou seja, std::basic_string).

Há também strings de largura fixa específicas, como a std::u32string (ou seja, std::basic_string) e a std::u16string (ou seja, std::basic_string).

No C++20, foi introduzido o char8_t, que também trouxe a std::u8string (ou seja, std::basic_string). Não sei por que foi preciso esperar até o C++20 para introduzir o char8_t; então deixo uma pergunta: em qual padrão char16_t e char32_t existem? Vejam na área de comentários

C++11

Sob o padrão C++11, o processamento de strings dependia principalmente da classe std::string, uma classe de string com alocação dinâmica de memória. Além disso, foram introduzidos novos tipos de string de largura fixa, como std::u32string e std::u16string, oferecendo melhor suporte ao tratamento de caracteres Unicode.

#include <iostream>
#include <string>

int main() {
    // 使用std::string
    std::string str = "Hello, C++11!";

    // 使用std::u32string和std::u16string
    std::u32string u32str = U"Hello, Unicode!";
    std::u16string u16str = u"Hello, Unicode!";

    std::cout << str << std::endl;
    std::wcout << u32str << std::endl;
    std::wcout << u16str << std::endl;

    return 0;
}

C++17

No C++17, foi introduzido o cabeçalho , que fornece uma alternativa leve e somente leitura ao uso dos tipos de string do cabeçalho . Essas visões de string são semelhantes às strings descritas anteriormente. Por exemplo, o equivalente em da std::u32string é a std::u32string_view (ou seja, std::basic_string_view).

Isso é particularmente útil em funções que precisam ler uma string, mas não precisam modificá-la. Em vez de criar cópias da string para a função, podemos simplesmente observar a string existente! Além disso, é muito flexível: não apenas strings no estilo C++ podem ser convertidas em visões de string, mas até mesmo strings no estilo C também. A seguir, um exemplo que demonstra o uso simples de std::string_view:

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

void printString(std::string_view str) {
  std::cout << str << std::endl;
}

int main() {
  std::string_view strv{"strv"}; // C++ string_view
  printString(strv);

  std::string str{"str"}; // C++ string
  printString(str);

  char cstr[] = "cstr"; // C-style string
  printString(cstr);

  return 0;
}

Saída:

strv
str
cstr

Neste exemplo, a função printString recebe std::string_view como parâmetro, o que torna a função muito leve e flexível: como nenhuma cópia de string é feita, ela pode ser usada de várias maneiras, passando-se strings no estilo C e no estilo C++.

C++20

No C++20, foram introduzidas algumas novas funções-membro úteis, incluindo starts_with(…) e ends_with(…). Como os nomes indicam, essas funções determinam se uma string (ou visão de string) começa/termina com determinado caractere ou com determinada std::string_view. Aqui está um exemplo simples:

#include <cassert>
#include <string>
#include <string_view>

int main() {
  const std::string str{"Hello World!"};

  assert(str.starts_with('H'));
  assert(str.ends_with('!'));

  assert(str.starts_with("Hello")); // 隐式转换为std::string_view
  assert(str.ends_with("World!")); // 隐式转换为std::string_view

  return 0;
}

C++23

O C++23 introduziu contains, usado para verificar se uma string contém uma substring especificada.

// 这是一个假设的C++23示例，实际上并不可用
#include <iostream>
#include <string>

int main() {
    std::string str = "C++23 introduces contains function.";

    if (str.contains("introduces")) {
        std::cout << "The string contains 'introduces'." << std::endl;
    } else {
        std::cout << "The string does not contain 'introduces'." << std::endl;
    }

    return 0;
}

https://en.cppreference.com/w/cpp/string/basic_string/contains

Conclusão

Ao lidar com strings em código C++ moderno, deve-se procurar deixar o código o mais flexível e eficiente em memória possível. Usar pode ajudar muito nesses esforços. Além disso, considere usar as funções-membro mais recentes de string, como starts_with e ends_with, para obter código de análise de strings legível e de fácil implementação. E o C++23 torna o cálculo com contains ainda mais simples — cada vez mais moderno.

Tópicos relacionados

Comentários