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

CKTIS / C++

Formar ponteiros para membros em C++

`&C::m` pode identificar um membro não estático sem escolher um objeto. O ponteiro resultante pode ser aplicado a um objeto ou usado como projeção num algoritmo de intervalos.

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

Sintaxe

T C::* pm = &C::m;
R (C::* pmf)(Args...) const = &C::f;
obj.*pm
ptr->*pm
(obj.*pmf)(args...)
(ptr->*pmf)(args...)

Para formar um ponteiro para membro, coloca-se o operador unário predefinido & imediatamente antes de um nome qualificado sem parênteses, como em &C::m. Nem &(C::m), nem C::m isolado, nem &m não qualificado formam esse ponteiro. Podem usar-se parênteses à volta da expressão completa (&C::m). O membro tem de estar acessível e não pode ser um campo de bits.

Se C::m for um membro de dados não estático do tipo int, &C::m tem o tipo int C::*: indica o membro a selecionar, não um objeto em particular nem um deslocamento em bytes portável. A classe que figura no tipo do ponteiro resultante é a que declara o membro, não necessariamente a que qualifica o seu nome. Se D herdar m de C e D::m designar esse membro herdado, &D::m também tem o tipo int C::*. Para um objeto existente obj da classe C, &obj.m tem o tipo int* e aponta para o membro desse objeto. O endereço de um membro estático do tipo int também tem o tipo int*.

Para uma função membro int C::f(int) const com parâmetro de objeto implícito, o tipo do ponteiro é int (C::*)(int) const. Se f estiver sobrecarregada, int (C::*pf)(int) const = &C::f; fornece um tipo de destino que tem de selecionar uma única função sem ambiguidade. O endereço de uma função membro estática ou com parâmetro de objeto explícito (this, C++23) produz um ponteiro normal para função.

Usa obj.*pm com um objeto ou ptr->*pm com um ponteiro para objeto. Chama uma função membro com (obj.*pf)(arg) ou (ptr->*pf)(arg). O objeto tem de pertencer à classe adequada ou a uma classe derivada em que a classe base desse tipo seja acessível e não ambígua. Também é possível aceder aos membros durante a construção e a destruição, de acordo com as regras de [class.cdtor]. Por exemplo, no corpo de um construtor é possível ler um membro de dados já inicializado através de um ponteiro para esse membro antes de começar o tempo de vida do objeto completo. Aplicar um ponteiro nulo para membro (nullptr) provoca comportamento indefinido.

Em std::ranges::sort(rows, std::ranges::less{}, &Row::key), o ponteiro para membro serve de projeção: o algoritmo compara os valores de key, mas reordena registos inteiros. Não é preciso definir uma comparação entre objetos Row inteiros.

Exemplos

#include <algorithm>
#include <functional>
#include <iostream>

struct Row {
    char label;
    int key;

    int value() const { return key; }
    int value(int factor) const { return key * factor; }
};

int main() {
    int Row::* key = &Row::key;
    int (Row::* read)(int) const = &Row::value;

    Row row{'A', 20};
    Row* ptr = &row;
    int* address = &row.key;
    std::cout << (row.*key) << ' ' << *address << ' '
              << (ptr->*read)(2) << '\n';

    Row rows[]{row, {'B', 10}, {'C', 30}};
    std::ranges::sort(rows, std::ranges::less{}, key);
    for (const Row& item : rows) {
        std::cout << item.label << ':' << item.key << '\n';
    }
}

Resultado

20 20 40
B:10
A:20
C:30

Os dois primeiros valores são `20`: um é obtido pelo ponteiro para membro e o outro pelo endereço de um membro específico. A sobrecarga selecionada `value(int) const` devolve `40`. Os registos inteiros surgem depois pela ordem `B`, `A`, `C`, por `key` crescente.

Lições relacionadas

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

Fontes