8

In my project, there are a few lines in a MyClass.h file

class MyClass{
public:
....

#ifndef __MAKECINT__
  std::vector<Status_e(MyClass::*)(TupleInfo & info)> m_processObjects; //!
#endif
....
}
//The Status_e is an enum type
//The TupleInfo is a struct

I can't understand what the usage of this * in above code snippet. And in the MyClass.cxx file, the m_processObjects used as this:

for (unsigned int f = 0; f < m_processObjects.size(); ++f) {
    status = (this->*m_processObjects[f])( m_tuples[i] );
    if ( status == FAILURE ) {
      return EL::StatusCode::FAILURE;
    }
....
}
....

I have never heard about the usage like this->*blabla, but this code snippet works. So what it means?

kvantour
  • 25,269
  • 4
  • 47
  • 72
spring cc
  • 937
  • 1
  • 10
  • 19
  • 3
    http://en.cppreference.com/w/cpp/language/pointer#Pointers_to_members – llllllllll May 17 '18 at 06:21
  • 1
    Actually, the symbol is `::*`. – Scheff's Cat May 17 '18 at 06:22
  • @RSahu The link for duplicate is not so lucky. Actually, a Q/A about pointer to member functions would match better e.g. [SO: Calling C++ class methods via a function pointer](https://stackoverflow.com/q/1485983/7478597). – Scheff's Cat May 17 '18 at 06:26
  • Let's give this question another chance. Reopened. m_processObjects is a std::vector of function pointers. – Bathsheba May 17 '18 at 06:26
  • Does this answer your question? [What are the Pointer-to-Member ->\* and .\* Operators in C++?](https://stackoverflow.com/questions/6586205/what-are-the-pointer-to-member-and-operators-in-c) – phuclv Oct 18 '20 at 13:38

1 Answers1

11

::* denotes a Pointer to member.

With the surrounding code it's actually a Pointer to member function.

Status_e(MyClass::*)(TupleInfo & info)

is a member function of class MyClass, returning Status_e, and having one parameter TupleInfo&. (The argument name info is useless here but obviously silently ignored by the compiler.)

The other snippet in OP's question shows how to call it:

status = (this->*m_processObjects[f])(m_tuples[i]);

Storing a method pointer would look like this:

std::vector<Status_e(MyClass::*)(TupleInfo & info)> m_processObjects;

...

m_processObjects.push_back(&MyClass::aMethod);

Of course, the signature of MyClass::aMethod must match.

A simplified sample to demonstrate it:

#include <iostream>
#include <vector>

class Test {
  
  private:
    std::vector<int(Test::*)(const char*)> _tblTestFuncs;
  public:
    Test()
    {
       _tblTestFuncs.push_back(&Test::func1);
       _tblTestFuncs.push_back(&Test::func2);
       _tblTestFuncs.push_back(&Test::func3);
    }
  
    int func1(const char *caller) { std::cout << "Test::func1 called from '"<< caller << "': "; return 1; }
    int func2(const char *caller) { std::cout << "Test::func2 called from '"<< caller << "': "; return 2; }
    int func3(const char *caller) { std::cout << "Test::func3 called from '"<< caller << "': "; return 3; }
    
    void call()
    {
      for (size_t i = 0, n = _tblTestFuncs.size(); i < n; ++i) {
        int result = (this->*_tblTestFuncs[i])("Test::call()");
        std::cout << "Return: " << result << '\n';
      }
    }
};

int main()
{
  Test test;
  // test method vector in main()
  std::vector<int(Test::*)(const char*)> tblTestFuncs;
  tblTestFuncs.push_back(&Test::func1);
  tblTestFuncs.push_back(&Test::func2);
  tblTestFuncs.push_back(&Test::func3);
  for (size_t i = 0, n = tblTestFuncs.size(); i < n; ++i) {
    int result = (test.*tblTestFuncs[i])("main()");
    std::cout << "Return: " << result << '\n';
  }
  // test method vector in Test
  test.call();
  // done
  return 0;
}

Output:

Test::func1 called from 'main()': Return: 1
Test::func2 called from 'main()': Return: 2
Test::func3 called from 'main()': Return: 3
Test::func1 called from 'Test::call()': Return: 1
Test::func2 called from 'Test::call()': Return: 2
Test::func3 called from 'Test::call()': Return: 3

Live Demo on coliru.com

Scheff's Cat
  • 19,528
  • 6
  • 28
  • 56