Operatory wskaźnika do składowych: `.` i `->`

2023-10-12

Składnia

pm-expression:
cast-expression
pm-expression .* cast-expression
pm-expression ->* cast-expression

Uwagi

Operatory .* wskaźnika do składowej i ->* zwracają wartość określonej składowej klasy dla obiektu określonego po lewej stronie wyrażenia. Po prawej stronie należy określić składową klasy. Poniższy przykład ilustruje sposób używania operatorów:

// expre_Expressions_with_Pointer_Member_Operators.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;

class Testpm {
public:
   void m_func1() { cout << "m_func1\n"; }
   int m_num;
};

// Define derived types pmfn and pmd.
// These types are pointers to members m_func1() and
// m_num, respectively.
void (Testpm::*pmfn)() = &Testpm::m_func1;
int Testpm::*pmd = &Testpm::m_num;

int main() {
   Testpm ATestpm;
   Testpm *pTestpm = new Testpm;

// Access the member function
   (ATestpm.*pmfn)();
   (pTestpm->*pmfn)();   // Parentheses required since * binds
                        // less tightly than the function call.

// Access the member data
   ATestpm.*pmd = 1;
   pTestpm->*pmd = 2;

   cout  << ATestpm.*pmd << endl
         << pTestpm->*pmd << endl;
   delete pTestpm;
}

Wyjście

m_func1
m_func1
1
2

W poprzednim przykładzie, wskaźnik do elementu członkowskiego, pmfn, jest używany do wywoływania funkcji członkowskiej m_func1. Inny wskaźnik do elementu członkowskiego, pmd, jest używany w celu uzyskania dostępu do członka m_num.

Operator .* binarny łączy swój pierwszy operand, który musi być obiektem typu klasy z drugim operandem, który musi być typem wskaźnika do składowej.

Operator ->* binarny łączy swój pierwszy operand, który musi być wskaźnikiem do obiektu typu klasy z drugim operandem, który musi być typem wskaźnika do składowej.

W wyrażeniu .* zawierającym operator pierwszy operand musi być typu klasy i być dostępny dla wskaźnika do składowej określonej w drugim operandzie lub typu dostępnego jednoznacznie pochodzącego z tej klasy i dostępnego dla tej klasy.

W wyrażeniu ->* zawierającym operator pierwszy operand musi być typu "wskaźnik do typu klasy" typu określonego w drugim operandzie lub musi być typu jednoznacznie pochodzącego z tej klasy.

Przykład

Rozważmy następujące klasy i fragment programu:

// expre_Expressions_with_Pointer_Member_Operators2.cpp
// C2440 expected
class BaseClass {
public:
   BaseClass(); // Base class constructor.
   void Func1();
};

// Declare a pointer to member function Func1.
void (BaseClass::*pmfnFunc1)() = &BaseClass::Func1;

class Derived : public BaseClass {
public:
   Derived();  // Derived class constructor.
   void Func2();
};

// Declare a pointer to member function Func2.
void (Derived::*pmfnFunc2)() = &Derived::Func2;

int main() {
   BaseClass ABase;
   Derived ADerived;

   (ABase.*pmfnFunc1)();   // OK: defined for BaseClass.
   (ABase.*pmfnFunc2)();   // Error: cannot use base class to
                           // access pointers to members of
                           // derived classes.

   (ADerived.*pmfnFunc1)();   // OK: Derived is unambiguously
                              // derived from BaseClass.
   (ADerived.*pmfnFunc2)();   // OK: defined for Derived.
}

Wynikiem operatorów .* lub ->* wskaźnik-składowy jest obiekt lub funkcja typu określonego w deklaracji wskaźnika do elementu członkowskiego. Dlatego w poprzednim przykładzie wynik wyrażenia ADerived.*pmfnFunc1() jest wskaźnikiem do funkcji zwracającej wartość void. Ten wynik jest wartością l, jeśli drugi argument operacji jest wartością l.

Uwaga

Jeżeli wynik jednego z operatorów wskaźnika do elementu członkowskiego jest funkcją, wynik może używany tylko jako argument operatora wywołania funkcji.

Zobacz też

Wbudowane operatory, pierwszeństwo i kojarzenie języka C++

Udostępnij za pośrednictwem

Operatory wskaźnika do składowych: .* i ->*