반환형이 포인터의 참조자입니다.

컴파일이 안될 것같은데... 역 어셈블 코드를 따라가셨다는 말씀은 컴파일이 되었다는 ...?

int*& 는 int 포인터의 레퍼런스 (int&* 이런 표현은 없습니다.) 그냥 그대로 받아들이면 됩니다.
함수의 인자로 넘길때는 넘긴 포인터가 다른 번지를 가르키게 할때 쓰고(이중 포인터보다 코드가 깔끔해지겠죠)
함수의 리턴타입으로 쓸때는.. **(double pointer)를 리턴하는 경우의 코드를 깔금하게 쓰고싶을때 (^^)
즉, C에서 **를 써야하는 경우 c++에서 *&를 쓰면 코드가 좀 더 깔끔해지는 잇점이 있습니다.

여담으로, 레퍼런스를 리턴하는 경우는 많죠. stack이라는 객체의 push가 stack&를 리턴하면
stack s; s.push(1).push(2).push(3); 이런 expression이 가능하겠죠.

First of all, sorry for English. My laptop which speaks Korean isn't available today. And I am slacking now :) So I will be quick.
What yielding-nim said was that Using *& in c++ takes advantage of reference. If the same thing should be written in C, double pointer should be involved.

I have made a quick-and-dirty example. Don't expect this to be a perfect one, though.

In C++,

#include <iostream>
#include <string>
using namespace std;
 
class Person {
public:
    Person(const string &);
    string name;
};
 
Person::Person(const string &n) : name(n) {}
 
Person *gPer;
 
Person*& personFactory(const string n) 
{
    extern Person *gPer;
    gPer = new Person(n);
    return gPer;
}
 
int main()
{
    Person *p = personFactory(string("Foo-bar"));
    cout << p->name << endl;
 
    return 0;
}

If we write the same code in C,

include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
struct Person {
    char name[50];
};
 
int createPerson(struct Person **p, const char *name)
{
    *p = malloc(sizeof (struct Person));
    if (!p) 
        return -1;
    strcpy((*p)->name, name);
    return 0;
}
 
int main()
{
    struct Person *p;
    createPerson(&p, "Foo-bar");
    printf("%s\n", p->name);
    return 0;
}

In C++ example, I used extern to denote that this memory block is managed by somebody else. Like application level data structure object.
I hope this makes sense to you.

삽질의 대마왕...

#include <iostream>
using std::cout;
int g[2] = { 1, 2 };
class A
{
public:
    int *p;
    A() { p = g; }
    int *&getp() { return p; }
};
 
int main()
{
    A a;
    cout << a.getp()[0] << std::endl;
    a.getp()++;
    cout << a.getp()[0] << std::endl;
}

결과를 해보면 1, 2가 나옵니다.

reference로 받는 다는 얘기는 받은 것을 단순히 사용하는 것 뿐 아니라 원래 값에 변형을 줄 수 있다는 얘기가 됩니다.
class A가 갖는 p라는 포인터 변수의 값을 a.getp()++; 로 바꿀 수 있다는 얘기죠.

포인터 증가 부분을

int *&p = a.getp(); p++;

로 쓰면 역시 1, 2가 나오는데

int *p = a.getp(); p++;

로 쓰면 1, 1이 나옵니다.

그리고 getp가

int *getp() { return p; }

라면

a.getp()++; // compile error
int *&p = a.getp(); p++; // compile error
int *p = a.getp(); p++; // ok

입니다. C로는 int ** 로 쓸 걸 int *&로 쓴 거라 이해하실 수도 있고요, 포인터라는 거 신경쓰지 마시고, int *와 int &의 차이를 생각해보시면 감이 오지 않을까 싶습니다.