Overloading member access operators ->, .*

by

->

This is the only really tricky one. It must be a nonstatic member function, and it takes no arguments. The return value is used to perform the member lookup.

If the return value is another object of class type, not a pointer, then the subsequent member lookup is also handled by an operator-> function. This is called the “drill-down behavior.” The language chains together the operator-> calls until the last one returns a pointer.

struct client
    { int a; };

struct proxy {
    client *target;
    client *operator->() const
        { return target; }
};

struct proxy2 {
    proxy *target;
    proxy &operator->() const
        { return * target; }
};

void f() {
    client x = { 3 };
    proxy y = { & x };
    proxy2 z = { & y };

    std::cout << x.a << y->a << z->a; // print "333"
}

->*

This one is only tricky in that there is nothing special about it. The non-overloaded version requires an object of pointer to class type on the left-hand side and an object of pointer to member type on the right. But when you overload it, you can take any arguments you like and return anything you want. It doesn’t even have to be a nonstatic member.

In other words, this one is just a normal binary operator like +, -, and /. See also: Are free operator->* overloads evil?

.* and .

These cannot be overloaded. There is already a built-in meaning when the left-hand side is of class type. Perhaps it would make a little sense to be able to define them for a pointer on the left-hand side, but the language design committee decided that would be more confusing than useful.

Overloading ->, ->*, ., and .* can only fill in cases where an expression would be undefined, it can never change the meaning of an expression that would be valid with no overloading.

More Related Contents:

  1. What are the basic rules and idioms for operator overloading?
  2. How should I write ISO C++ Standard conformant custom new and delete operators?
  3. Why would one replace default new and delete operators?
  4. How do I prevent a class from being allocated via the ‘new’ operator? (I’d like to ensure my RAII class is always allocated on the stack.)
  5. Rationale of enforcing some operators to be members
  6. Where and why do I have to put the “template” and “typename” keywords?
  7. What is this weird colon-member (” : “) syntax in the constructor?
  8. What are rvalues, lvalues, xvalues, glvalues, and prvalues?
  9. overloading friend operator
  10. Can a class member function template be virtual?
  11. What is a “span” and when should I use one?
  12. What does T&& (double ampersand) mean in C++11?
  13. What is std::move(), and when should it be used?
  14. Operator overloading : member function vs. non-member function?
  15. Polymorphism in C++
  16. What is the correct answer for cout
  17. Is the practice of returning a C++ reference variable evil?
  18. Lifetime of temporaries
  19. Why are C++ inline functions in the header?
  20. What are template deduction guides and when should we use them?
  21. Why is ‘this’ a pointer and not a reference?
  22. Template specialization of particular members?
  23. What are the advantages of using nullptr?
  24. Overloading ++ for both pre and post increment
  25. Why is “operator void” not invoked with cast syntax?
  26. shared_from_this causing bad_weak_ptr
  27. Implicit conversion when overloading operators for template classes
  28. Conversion from Derived** to Base**
  29. How to differentiate (when overloading) between prefix and postfix forms of operator++? (C++)
  30. std::getline() reads carriage return \r into the string, how to avoid that?

Leave a Comment