KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

`std::vector::data`: bufferpointer en bereikgrenzen

Vraag een pointer naar de elementen van een vector op, geef die samen met het aantal elementen door en weet wanneer de pointer ongeldig wordt.

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

Syntax

#include <vector>

// Member declarations of std::vector<T, Allocator> (T != bool):
constexpr T* data() noexcept;
constexpr const T* data() const noexcept;

std::vector::data uit <vector> geeft in constante tijd een ruwe pointer naar het aaneengesloten geheugen van de vector terug, zonder gegevens te kopiëren of eigendom over te dragen. Bij een niet-lege vector is dat het adres van het eerste element. Een vector zonder const geeft T* terug, waarmee je bestaande elementen kunt wijzigen; een const-vector geeft const T* terug. Via const T* kun je geen nieuwe waarde toekennen aan het element zelf, maar als T een klassetype is, kun je de als mutable gedeclareerde leden van het element wel wijzigen. Beide overloads zijn noexcept en sinds C++20 constexpr. De specialisatie std::vector<bool> heeft geen standaardlidfunctie data().

Als p = v.data() en n = v.size(), dan is [p, p + n) een geldig halfopen bereik. Bij een niet-lege vector wijst p + n direct voorbij het laatste element; derefereer deze pointer nooit. Bij n == 0 kan p wel of niet nullptr zijn, maar in beide gevallen mag je de pointer niet derefereren. Test v.empty() of n == 0, niet of de pointer null is.

Geef aan de functie die de buffer verwerkt de pointer en het aantal elementen door, of twee pointers die het bereik begrenzen. size() telt elementen, geen bytes; voor char zijn die aantallen gelijk. Een std::vector<char>-buffer heeft geen automatisch afsluitend \0-teken, en een interne \0 stopt een leesbewerking met een opgegeven lengte niet. Controleer bij een lege buffer of de functie nul elementen en een mogelijk nullpointer accepteert. reserve() alleen maakt geen elementen aan: gebruik resize() voordat je naar extra elementen schrijft.

Geef het geheugen niet vrij via de pointer en gebruik hem niet nadat de buffer is vernietigd. Herallocatie maakt pointers naar de elementen en de oude eindgrens ongeldig. push_back() kan herallocatie veroorzaken. Ook zonder herallocatie moet je de eindgrens opnieuw berekenen, hoewel een pointer naar een bestaand eerste element geldig blijft. Na structurele wijzigingen aan de vector kun je het eenvoudigst data() en size() opnieuw opvragen.

Voorbeelden

#include <cstddef>
#include <iostream>
#include <vector>

void print_bytes(const char* first, std::size_t count) {
    const char* last = first + count;
    for (auto p = first; p != last; ++p) {
        std::cout << (*p == '\0' ? '0' : *p) << ' ';
    }
    std::cout << '\n';
}

int main() {
    std::vector<char> bytes{'A', '\0'};
    bytes.push_back('B');
    const auto& input = bytes;
    print_bytes(input.data(), input.size());
}

Resultaat

A 0 B 

`print_bytes` berekent de pointer direct voorbij het laatste element en verwerkt alle drie de bytes. De functie toont de interne `\0` als een zichtbare `0`. `<<` voegt na elk teken een spatie in, ook na `B`, vóór de regelafbreking.

Gerelateerde lessen

  • C++ · Les 27 · Gevorderd · Versie: 3
  • C++ · Les 58 · Gevorderd · Versie: 3

Bronnen