使用对指针的引用作为函数参数的危险

有人能告诉我这是否安全吗，因为我认为不是：

class A
{
public:
A(int*& i) : m_i(i)
{}
int*& m_i;
};
class B
{
public:
B(int* const& i) : m_i(i)
{}
int* const & m_i;
};

int main()
{
int i = 1;
int *j = &i;
A a1(j);   // this works (1)
A a2(&i);  // compiler error (2)
B b(&i);   // this works again (3)
}

我理解为什么(1)有效。我们正在传递一个指针，函数接受它作为引用。

但为什么(2)不起作用呢？从我的角度来看，我们传递的是同一个指针，只是没有先将其分配给指针变量。我的猜测是&i是一个右值，并且没有自己的内存，所以引用不可能有效。我可以接受那个解释(如果是真的)。

但是为什么要编译呢？这难道不意味着我们允许无效引用，所以b.m_i本质上是未定义的吗？

我是不是完全错了？我之所以这么问，是因为我遇到了奇怪的单元测试失败，我只能通过指针无效来解释。它们只在某些编译器中发生，所以我认为这一定是标准之外的东西。

因此，我的核心问题基本上是：在函数参数中使用int* const &是否本质上是危险的，应该避免，因为毫无戒心的调用者可能总是像使用常规指针参数一样使用&i来调用它？

附录：正如@franji1所指出的，以下是一个有趣的想法，可以理解这里发生了什么。我修改了main()来更改内部指针，然后打印成员m_i:

int main()
{
int i = 1;
int *j = &i;  // j points to 1
A a1(j);
B b(&i);
int re = 2;
j = &re;  // j now points to 2
std::cout << *a1.m_i << "n";  // output: 2
std::cout << *b.m_i << "n";  // output: 1
}

因此，显然a1按预期工作。然而，由于b不知道j已经被修改，它似乎引用了一个"个人"指针，但我担心的是，它在标准中没有得到很好的定义，因此可能有编译器没有定义这个"个人"指示器。有人能证实吗？