Question: I'll illustrate my question with code:

```
#include <iostream>

void PrintInt(const unsigned char*& ptr)
{
    int data = 0;
    ::memcpy(&data, ptr, sizeof(data));
    // advance the pointer reference.
    ptr += sizeof(data);
    std::cout << std::hex << data << " " << std::endl;
}

int main(int, char**)
{
    unsigned char buffer[] = { 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, };

    /* const */ unsigned char* ptr = buffer;

    PrintInt(ptr);  // error C2664: ...
    PrintInt(ptr);  // error C2664: ...    

    return 0;
}

```

When I run this code (in VS2008) I get this: error C2664: 'PrintInt' : cannot convert parameter 1 from 'unsigned char \*' to 'const unsigned char \*&'. If I uncomment the "const" comment it works fine.

However shouldn't pointer implicitly convert into const pointer and then reference be taken? Am I wrong in expecting this to work? Thanks!

Answer: 
If the pointer gets converted to a const pointer, as you suggest, then the result of that conversion is a temporary value, an *rvalue*. You cannot attach a non-const reference to an rvalue - it is illegal in C++. 

For example, this code will not compile for a similar reason

```
int i = 42;
double &r = i;

```

Even though type `int` is convertible to type `double`, it still doesn't mean that you can attach a `double &` reference to the result of that conversion. 

However, a const reference (i.e. a reference of reference-to-const type) can be attached to an rvalue, meaning that this code will compile perfectly fine

```
int i = 42;
const double &r = i;

```

In your case if you declare your function as 

```
void PrintInt(const unsigned char* const& ptr) // note the extra `const`

```

the code will compile.
You cannot convert a reference to a pointer because the pointer can be null and a reference can't. In other words the reference is more restrictive that a pointer. A reference is always a valid pointer but the opposite is not always true.