Passing pointer to function expecting reference changes the value pointed - c++

Question

I have following code example. I am passing the pointer to a function. When I pass the pointer to the function it seems the function initializes the argument to some random number. But, when I pass the address of the variable to the function it gives expected result.
// find_if example
#include <iostream> // std::cout
#include <algorithm> // std::find_if
#include <vector> // std::vector
class A
{
public:
A(int i) { num = i; }
bool IsPresent (A& a) {
std::cout << "Comparing " << num << " vs " << a.num << '\n';
return (num == a.num);
};
int num;
};
int main () {
std::vector<A*> myvector;
A a1(10);
A a2(20);
A a3(30);
A a4(40);
A a(40);
const A *pa = &a;
std::cout << "pa is " << pa << '\n';
myvector.push_back(&a1);
myvector.push_back(&a2);
myvector.push_back(&a3);
myvector.push_back(&a4);
std::vector<A*>::iterator it = std::find_if (myvector.begin(), myvector.end(),
std::bind2nd(std::mem_fun(&A::IsPresent), pa));
if (it != myvector.end())
std::cout << "The first equal value is " << (*it)->num << '\n';
else
std::cout << "Cannot find a match";
return 0;
}
Why the function bool IsPresent (A& a) initializes the variable (A& a) to random value when the parameter is passed by pointer and works when I pass reference of it?
When passed as pointer the result is
pa is 0x7b10b4d52e80
Comparing 10 vs -1261097344
Comparing 20 vs -1261097344
Comparing 30 vs -1261097344
Comparing 40 vs -1261097344
Cannot find a match
When Passed as reference:
pa is 0x75002e9dbb30
Comparing 10 vs 40
Comparing 20 vs 40
Comparing 30 vs 40
Comparing 40 vs 40
The first equal value is 40
And why the code compiles in first place? The function I am calling expects a reference and I am passing a pointer. Shouldn't the compiler give a warning/error as function not found?

Answer 1

std::bind2nd is really poorly designed.
template< class F, class T >
std::binder2nd<F> bind2nd( const F& f, const T& x )
evaluates to:
std::binder2nd<F>(f, typename F::second_argument_type(x))
and yes, that is a C-style cast.
We end up with doing an (A&)(pa), which becomes reinterpret_cast<A&>(pa).
Which reinterprets the memory of the pointer to A as an instance of A.
Did I say that bind2nd was poorly designed? I meant it.
C++11 brings lambdas and std::bind, both of which are head and shoulders and body and feet and foundation and planet above bind2nd and bind1st.
There is a reason why std::bind2nd is deprecated and removed from the standard. This is only part of the reason (also because it relies on its function arguments telling it what the argument types are, which std::bind does not).
std::mem_fun is also deprecated and removed from the standard, but it does nothing wrong here. Still, replace it with std::mem_fn which does the same job but better as a first step.
Your code will fail to compile if you blindly replace std::mem_fun with std::mem_fn and std::bind2nd with std::bind( first_arg, std::_1, second_arg ) unless second_arg matches the right type. It will do so in a spew of template spam.
Better is:
std::vector<A*>::iterator it = std::find_if (
myvector.begin(), myvector.end(),
[pa](A* a){ a->IsPresent(*pa); }
);
which if you forget to dereference pa generates a really simple and easy to read compiler error message.

Answer 2

Why the function bool IsPresent (A& a) initializes the variable (A& a) to random value when the parameter is passed by pointer and works when I pass reference of it?
The "A& a" parameter is defined as a reference variable, when you pass the pointer object, it is trying to interpret the object as a reference. The correct way is pass its content.
In order to improve your solution, you can define isPresent as bool isPresent(const A& a)
And why the code compiles in first place? The function I am calling expects a reference and I am passing a pointer. Shouldn't the compiler give a warning/error as function not found?
It can be interpreted wrongly as a reference. As a result it compile correctly but the execution fails.