How to overload operator<< with a reference pointer on the RHS?

I am guessing that -- in the spirit of similar overloaded functions -- you were trying to make your parameter a const reference. That is, a reference to a const object.

Your parameter:

 const A*& handle

Is not a const reference. It's a (reference &) to a (mutable pointer *) to a (const A).

Change your parameter to this and it will work:

 A *const & handle

This is a (reference &) to a (const pointer *const) to an (A).

Whether A is const or not is up to you and the intentions of your code.

See it working in Compiler Explorer.

#include <iostream>
using namespace std;

class A
{
 public:
   void print(ostream& out) const { out << "Hello World!"; }
};

ostream& operator<<(ostream& out, const A*& handle)
{
   handle->print(out);
   return out;
}

int main() {
   A *a = new A();
   cout << a << endl;
   delete a;
}

operator<< function expects reference to pointer of A object in your code. You may use ref to pointer function, for example, to change the address of the parameter because if you call the function by sending pointer and expecting pointer as in the below then the function copies the address of the object to that pointer points to use in its stack and loses the address of the pointer, so the function cannot change the address of the parameter.

You can change the signature in two ways like those, then it works:

ostream& operator<<(ostream& out, const A* handle)

Here, the caller calls the function with pass by value of A*, then inside the function it accesses the print function.

Second way about which also your other question is, to correct the mismatch by adding const keyword to the variable within main function or deleting const keyword in the signature of the function. Converting a non-const pointer to const reference to pointer implicitly may yield an invalid state:

int* p;
const int x;
// a now reference to pointer p; it is not valid operation sure
const int*& a = p;  
// if this operation was allowed and if we also changed the address
// to that p points 
*a = &x;
// then it would allow p to access and change const so we would change const data through non-cont pointer. 

 

Given the comments so far, I did some more experiments. It all boils down to the match between a call and a function signature. The following code demonstrates this:

#include <iostream>
using namespace std;

void test(int& a) { // I can remove this function.
   cout << "void test(int& a): a = "
        << a << endl;
}

void test(const int& a) {
   cout << "void test(const int& a): a = "
        << a << endl;
}

void test(int*& a) { // I cannot remove this function.
   cout << "void test(int*& a): a = "
        << *a << endl;
}

void test(const int*& a) {
   cout << "void test(const int*& a): a = "
        << *a << endl;
   a = a + 3;
}

int main() {
   int a = 2, c = 5;
   const int b = 3, d = 7;
   int* pc = &c;
   const int* pd = &d;
   test(a);
   test(b);
   test(pc);
   test(pd);
}  

The code prints

void test(int& a): a = 2
void test(const int& a): a = 3
void test(int*& a): a = 5
void test(const int*& a): a = 7

Curiously, I can remove the function void test(int& a) and the call test(a) will use the function void test(const int& a). By contrast, I cannot remove the function void test(int*& a) and the call test(pc) will still not match the function void test(const int*& a).

If someone can explain this difference in the comments, I can mark this question as answered.