Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::optional::operator-> — acesso a um membro do valor contido

Usa `->` para aceder a um membro do valor guardado em `std::optional`. Em C++23, verifica se o valor está presente antes de usar o operador.

Versão: ISO C++23; implementation support may vary

Sintaxe

In <optional>, std::optional<T> declares:
constexpr T* operator->() noexcept;
constexpr const T* operator->() const noexcept;

Member access: opt->member or opt->method(args...)
C++23 precondition: opt.has_value() is true when operator->() is called.

std::optional::operator-> está disponível em <optional> desde C++17. Em opt->member, C++ chama o operador sobrecarregado e depois aplica o operador -> incorporado ao ponteiro devolvido. O resultado é T* para um std::optional<T> não const e const T* para um const. Ambas as sobrecargas são constexpr e noexcept; nenhuma copia o valor.

Em C++23, chamar este operador num optional vazio tem comportamento indefinido: não esperes nullptr nem uma exceção. Usa if (opt) ou opt.has_value() e só acede ao valor enquanto este estiver presente. if (opt) usa o operator bool explícito numa conversão contextual: testa a presença, não o valor em si. Para um acesso com verificação, opt.value() lança std::bad_optional_access se não houver valor.

*opt dá uma referência em vez de um ponteiro e também exige que haja um valor presente. O ponteiro obtido de operator-> não é proprietário do valor nem prolonga o seu tempo de vida. Não o uses para aceder ao valor depois de este deixar de existir, por exemplo após reset() ou a destruição do optional.

No exemplo, fs é um alias do espaço de nomes std::filesystem. O & em const std::optional<fs::path>& borrowedpath declara uma referência lvalue para um tipo qualificado com const: o parâmetro não copia o optional e -> seleciona a sobrecarga const. Um caminho vazio continua a ser um valor presente; path::empty() não consulta o sistema de ficheiros.

Exemplos

#include <filesystem>
#include <iostream>
#include <optional>
#include <utility>

namespace fs = std::filesystem;

void describe(const std::optional<fs::path>& borrowedpath)
{
    if (borrowedpath) {
        std::cout << (borrowedpath->empty() ? "empty path\n" : "nonempty path\n");
    } else {
        std::cout << "no value\n";
    }
}

int main()
{
    const std::optional<fs::path> present{std::in_place};
    const std::optional<fs::path> absent;
    describe(present);
    describe(absent);
}

Resultado

empty path
no value

A primeira chamada escreve `empty path` porque existe um valor, mas o caminho está vazio. A segunda escreve `no value` e não avalia `->`.

Lições relacionadas

  • C++ · Lição 48 · Avançado · Versão: 3

Fontes