std::vector<T,Allocator>::data

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

std::vector

Member types
Member functions
vector::vector vector::~vector vector::operator= vector::assign vector::assign_range (C++23)   vector::get_allocator Element access vector::operator[] vector::at vector::data vector::front vector::back Iterators vector::beginvector::cbegin (C++11) vector::endvector::cend (C++11) vector::rbeginvector::crbegin (C++11) vector::rendvector::crend (C++11)	Capacity vector::empty vector::size vector::max_size vector::reserve vector::capacity vector::shrink_to_fit (DR*) Modifiers vector::clear vector::erase vector::insert vector::insert_range (C++23) vector::append_range (C++23) vector::emplace (C++11) vector::emplace_back (C++11) vector::push_back vector::pop_back vector::resize vector::swap
Non-member functions
operator==operator<=> (C++20) swap(std::vector) erase(std::vector)erase_if(std::vector) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)
Deduction guides(C++17)

 

T* data();	(1)	(noexcept since C++11) (constexpr since C++20)
const T* data() const;	(2)	(noexcept since C++11) (constexpr since C++20)

Returns a pointer to the underlying array serving as element storage. The pointer is such that range [data(), data() + size()) is always a valid range, even if the container is empty (data() is not dereferenceable in that case).

Parameters

(none)

Return value

Pointer to the underlying element storage. For non-empty containers, the returned pointer compares equal to the address of the first element.

Complexity

Constant.

Notes

If size() is ​0​, data() may or may not return a null pointer.

Example

Run this code

#include <cstddef>
#include <iostream>
#include <span>
#include <vector>
 
void pointer_func(const int* p, std::size_t size)
{
    std::cout << "data = ";
    for (std::size_t i = 0; i < size; ++i)
        std::cout << p[i] << ' ';
    std::cout << '\n';
}
 
void span_func(std::span<const int> data) // since C++20
{
    std::cout << "data = ";
    for (const int e : data)
        std::cout << e << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::vector<int> container{1, 2, 3, 4};
 
    // Prefer container.data() over &container[0]
    pointer_func(container.data(), container.size());
 
    // std::span is a safer alternative to separated pointer/size.
    span_func({container.data(), container.size()});
}

Output:

data = 1 2 3 4
data = 1 2 3 4

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 464	C++98	vector did not have this member function	added
LWG 1312	C++98	the return type were pointer and const_pointer	changed to T* and const T* respectively

See also

front	access the first element (public member function)
back	access the last element (public member function)
size	returns the number of elements (public member function)
operator[]	access specified element (public member function)
span (C++20)	a non-owning view over a contiguous sequence of objects (class template)
data (C++17)	obtains the pointer to the underlying array (function template)

1. ifndef _MODBUSRTU_
2. define _MODBUSRTU_

1. include <cstdint>
2. include <vector>
3. include "Mensaje.hpp"

class ModbusRTU {

private:

 uint8_t _id; // Dirección del dispositivo ModbusRTU
 std::vector<bool> _DO; // Registro de salidas digitales
 std::vector<uint16_t> _AO; // Registro de salidas analógicas
 std::vector<bool> _DI; // Registro de entradas digitales
 std::vector<uint16_t> _AI; // Registro de entradas analógicas

 unsigned _petRecibidas = 0; // Número de peticiones recibidas
 unsigned _byteRecibidos = 0; // Número de bytes recibidos (sin CRC)
 unsigned _byteEnviados = 0; // Número de bytes enviados (sin CRC)

 Mensaje atiende03(Mensaje& recibido); // Lectura de salidas analógicas
 Mensaje atiende06(Mensaje& recibido); // Fuerza una única salida analógica
 Mensaje atiende16(Mensaje& recibido); // Fuerza múltiples salidas analógicas
 Mensaje atiende01(Mensaje& recibido); // Lectura de salidas digitales
 Mensaje atiende05(Mensaje& recibido); // Fuerza una única salida digital
 Mensaje atiende15(Mensaje& recibido); // Fuerza múltiples salidas digitales
 Mensaje atiende02(Mensaje& recibido); // Lectura de entradas digitales
 Mensaje atiende04(Mensaje& recibido); // Lectura de entradas analógicas

 // Comprueba si el acceso a un registro está fuera de rango
 template <class T, class U=uint16_t> bool dentroDeRango(
     const std::vector<T>& registro, U offset, U numPos=0) const;

 // Genera un mensaje de error dado un mensaje recibido y un código de
 // error
 static Mensaje generaError(Mensaje& recibido, uint8_t errorCode);

 // Comprueba si un mensaje es válido
 static bool esValido(Mensaje& recibido, uint8_t funcion);

 // Actualiza los valores de entrada analógicas según varios parámetros
 void actualizaAI();

 // Muestra el valor de un registro por std::cerr (debugging)
 template <class T> void muestraRegistro(
     const std::vector<T>& registro,
     const std::string& identificador) const;

public:

 // Constructor donde se especifica el identificador del dispositivo.
 explicit ModbusRTU(uint8_t id);

 // Recibe como parámetro un mensaje de petición Modbus/RTU y devuelve
 // la respuesta correspondiente.
 Mensaje peticion(Mensaje& recibido);

};

1. endif //_MODBUSRTU_