KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::basic_string::size — elementen in een tekenreeks tellen

`size()` telt opgeslagen elementen, niet de tekens die een gebruiker waarneemt. Gebruik de waarde om kopieën af te bakenen, indexen te controleren en velden in te korten.

Versie: ISO C++23; implementation support may vary

Syntax

#include <string>

// Member declaration inside std::basic_string<CharT, Traits, Allocator> (C++23):
constexpr size_type size() const noexcept;

std::basic_string::size is een const-lidfunctie zonder parameters, gedeclareerd in <string>. De functie retourneert het aantal CharT-elementen als het type size_type, een geheel getal zonder teken. Ze werkt in constante tijd O(1), wijzigt de tekenreeks niet, is noexcept en is sinds C++20 constexpr. length() geeft dezelfde waarde terug; capacity() beschrijft de opslagcapaciteit, niet de lengte van de inhoud.

Ingebedde nulelementen tellen mee, maar het afsluitende nulteken telt niet mee. Bij std::string telt de functie char-elementen, oftewel C++-bytes; bij een std::u8string met UTF-8-tekst telt ze char8_t-code-eenheden. De functie telt geen Unicode-codepunten of door de gebruiker waargenomen tekens. Inkorten op basis van het aantal elementen kan een UTF-8-reeks doorsnijden.

Geef voor een exacte kopie s.data() en s.size() door aan een interface die een aantal elementen verwacht; een interface die het afsluitende nulteken zoekt, stopt bij de eerste nul. Is de doelbuffer in bytes gemeten, controleer dan de grootte in bytes: de inhoud beslaat s.size() * sizeof(CharT) bytes, zonder het afsluitende nulteken. Gebruik een pointer uit data() niet nadat de tekenreeks is vernietigd of een bewerking de pointer ongeldig heeft gemaakt.

Controleer vóór het lezen van een element met s[i] of i < s.size(); op positie s.size() staat het afsluitende nulteken, geen deel van de inhoud. at(i) werpt std::out_of_range op als i >= s.size(). Gebruik om hoogstens de laatste vier elementen te behouden s.substr(n - 4) alleen als n = s.size() groter is dan 4; behoud anders de hele tekenreeks. Zo voorkom je dat een aftrekking zonder teken modulo het bereik van het type omklapt. Is een scheidingsteken verplicht, vergelijk dan het resultaat van find() met npos voordat je het begin van het volgende veld berekent.

Voorbeelden

#include <iostream>
#include <string>

int main() {
    const std::string record("ID\0:123456", 10);
    const std::string copy(record.data(), record.size());
    const auto separator = copy.find(':');
    if (separator == std::string::npos) {
        return 1;
    }

    const auto field = copy.substr(separator + 1);
    constexpr std::string::size_type width = 4;
    const auto n = field.size();
    const auto tail = n > width ? field.substr(n - width) : field;
    const std::u8string utf8 = u8"\u00E9";

    std::cout << static_cast<unsigned int>(record.size()) << '\n'
              << (copy[2] == '\0') << '\n'
              << tail << '\n'
              << static_cast<unsigned int>(utf8.size()) << '\n';
}

Resultaat

10
1
3456
2

`10` telt de ingebedde nul mee en `1` bevestigt dat die in de kopie staat. `3456` zijn de laatste vier elementen van het veld en `2` is het aantal UTF-8-code-eenheden voor U+00E9.

Gerelateerde lessen

  • C++ · Les 49 · Gevorderd · Versie: 3
  • C++ · Les 53 · Gevorderd · Versie: 3
  • C++ · Les 58 · Gevorderd · Versie: 3

Bronnen