What does ., -> and .-> mean in C++?

Question

I have been recently learning how to use the std::mem_fn library facility. In C++ Primer 5th edition they give an example of a usage of std::mem_fn, in the following code snippet svec is a vector of strings:

auto f = mem_fn(&string::empty); // f takes a string or a string*

f(*svec.begin()); // ok: passes a string object; f uses .* to call empty

f(&svec[0]); // ok: passes a pointer to string; f uses .-> to call empty

Note: In the above code snippet there is no use of ->*

Although I understand the usage .* and ->*. I don't have clarity on it.

So, My question is what does .*, ->*, .-> do?

I don't think I've ever seen `.->`. Regardless, these are member function pointer calls, covered in great detail on the [C++ FAQ](https://isocpp.org/wiki/faq/pointers-to-members). — nneonneo, Jun 21 '15 at 07:15
Someone should talk to the C++ Primer people on "why you really shouldn't take the addresses of member functions of standard library classes". — T.C., Jun 21 '15 at 07:30
possible duplicate of [What are the Pointer-to-Member ->\* and .\* Operators in C++?](http://stackoverflow.com/questions/6586205/what-are-the-pointer-to-member-and-operators-in-c) — Sneftel, Jun 21 '15 at 08:11
@CppProgrammer There is massive implementation freedom with those functions; implementation are allowed to add additional overloads, extra parameters with default arguments, etc., all of which can break your address-taking code. — T.C., Jun 21 '15 at 09:24

score 3 · Answer 1 · answered Jun 21 '15 at 08:07

3

You have an object o and a pointer to its member m. The operator .* allows you to access the pointed member of your object:

o.*m

You have a pointer to an object p and a pointer to its member m. The operator ->* allows you to access the pointed member of the pointed object:

p->*m

I am afraid that the operator .-> doesn't exist.

answered Jun 21 '15 at 08:07

dlask

8,776
1
26
30

1

"The operator `.*`"... "The operator `->*`"... NO, that is *not* an operator! It's *two* operators! – Jun 21 '15 at 08:10
4

@Mints97 No, it's one. http://stackoverflow.com/questions/6586205/what-are-the-pointer-to-member-and-operators-in-c – Sneftel Jun 21 '15 at 08:11
1

If it were two, the code would not compile, because a class member pointer cannot be directly dereferenced. – Sneftel Jun 21 '15 at 08:12
1

@Mints97 The C++ language specification doesn't agree with you. – dlask Jun 21 '15 at 08:13
Does that mean that the authors of C++ Primer 5th edition have got an error? – Cpp Programmer Jun 21 '15 at 08:57
@CppProgrammer What do they say? – dlask Jun 21 '15 at 08:58
@dlask They have used .-> which is an error, so does that mean their usage of .-> is wrong? – Cpp Programmer Jun 21 '15 at 09:08
It would deserve its own question at Stackoverflow. Anyway, what do they actually say about this operator? Do their examples compile successfully? – dlask Jun 21 '15 at 09:12
@dlask Nope they don't give any kind of explanation about that operator and neither does it compile on my system running Clang. – Cpp Programmer Jun 21 '15 at 09:22
And also the reason why it is not compiling is because of the initialization of f. – Cpp Programmer Jun 21 '15 at 09:23
It means that authors of the book and (at least) the clang compiler differ in their opinion about this operator. – dlask Jun 21 '15 at 09:24

Veritas · Answer 2 · 2015-06-21T08:41:42.490

The .* and ->* operators are called pointer to member access operators and like their name suggests they allow you to access an object's data or function member given an appropriate pointer to that class member.

struct foo
{
    int a;
    float b;
    void bar() { std::cout << "bar\n"; }
};

int main()
{
    int foo::* ptra = &foo::a;
    float foo::* ptrb = &foo::b;
    void (foo::* ptrbar)() = &foo::bar;

    foo f;
    foo * fptr = &f;

    f.*ptra = 5;
    f.*ptrb = 10.0f;
    (f.*ptrbar)();

    fptr->*ptra = 6;
    fptr->*ptrb = 11.0f;
    (fptr->*ptrbar)();

    return 0;
}

anatolyg · Answer 3 · 2015-06-21T08:26:32.860

Operators .* and ->* call a member function (BTW there is no meaning for .-> in C++ - it's a syntax error).

These are binary operators. The left operand is an object (for .*) or a pointer to an object (for ->*), and the right operand is a pointer to a member (which can be a member field or a member function). The outcome of applying this operator is the ability to use a member field or a method.

Maybe these operators make sense from a historical point of view. Suppose you use a regular C pointer to a function:

typedef int (*CalcResult)(int x, int y, int z);
CalcResult my_calc_func = &CalcResult42;
...
int result = my_calc_func(11, 22, 33);

What if you decided to "rewrite" your program in an object-oriented way? Your calculation function would be a method in a class. To make a pointer to it, you need a new type, a pointer to member function:

typedef int (MyClass::*CalcResult)(int x, int y, int z);
CalcResult my_calc_func = &MyClass::CalcResult42;
...
MyClass my_object;
int result = (my_object.*my_calc_func)(11, 22, 33);

I always use this analogy when I try to remember the syntax of this .* operator - this helps because the regular pointer-to-function syntax is less convoluted and used more frequently.

Please note the parentheses:

int result = (my_object.*my_calc_func)(11, 22, 33);

They are almost always needed when using this .* operator, because its precedence is low. Even though my_object .* (my_calc_func(11, 22, 33)) is meaningless, the compiler would try to make sense of it if there were no parentheses.

The ->* operator works in essentially the same way. It would be used if the object on which to apply the method is given by a pointer:

typedef int (*MyClass::CalcResult)(int x, int y, int z);
CalcResult my_calc_func = &MyClass::CalcResult42;
...
MyClass my_object1, my_object2;
MyClass* my_object = flag ? &my_object1 : &my_object2;
int result = (my_object->*my_calc_func)(11, 22, 33);

What does .*, ->* and .-> mean in C++?

3 Answers3

What does ., -> and .-> mean in C++?