为什么我不需要检查引用是否无效/为空？

Question

阅读http://www.cprogramming.com/tutorial/references.html，它说:

一般来说，参考文献应该始终 是有效的，因为你必须始终 初始化一个引用。这意味着 除非有一些奇怪的事情 情况（见下文），您可以 确定使用参考只是 就像使用普通的旧非参考 多变的。您无需检查 确保参考不是 指向 NULL，你不会得到 被未初始化的引用咬住 你忘记分配内存了 对于。

我的问题是我如何知道在初始化引用后该对象的内存尚未被释放/删除。

归根结底，我不能凭信心接受这个建议，我需要更好的解释。

任何人都可以透露一些信息吗？

Answer 1

您无法知道引用是否无效：

除非注意如何使用引用，否则无法知道您的引用是否引用了有效内存。例如，如果您不确定何时删除内存，则您不想使用在堆上创建的内容的引用。

您也永远无法知道您使用的指针是否指向有效的内存。

您可以对指针和引用执行 NULL 检查，但通常您永远不会对引用执行 NULL 检查，因为没有人会编写这样的代码：

int *p = 0;
int &r = *p;//no one does this
if(&r != 0)//and so no one does this kind of check
{
}

---

何时使用引用？

您可能想要使用在这样的情况下引用：

//I want the function fn to not make a copy of cat and to use
// the same memory of the object that was passed in
void fn(Cat &cat)
{
   //Do something with cat
}

//...main...
Cat c;
fn(c);

---

使用引用搬起石头砸自己的脚是很困难的：

使用引用搬起石头砸自己的脚比使用指针要困难得多。

例如：

int *p;
if(true)
{
  int x;
  p = &x;
}

*p = 3;//runtime error

您不能使用引用执行此类操作，因为引用必须使用其值进行初始化。并且您只能使用您范围内的值来初始化它。

你仍然可以通过参考文献搬起石头砸自己的脚，但你必须真正尝试去做。

例如：

int *p = new int;
*p = 3;
int &r = *p;
delete p;
r = 3;//runtime error

Answer 2

你不能。你也不能用指针。考虑一下：

struct X
{
  int * i;
  void foo() { *i++; }
};

int main()
{
  int *i = new int(5);
  X x = { i };
  delete i;
  x.foo();
}

现在，您可以在 X::foo() 中放入什么代码来确保 i 指针仍然有效？

答案是没有标准检查。有一些技巧可能在调试模式下的 msvc 上起作用（检查 0xfeeefeee 或其他），但没有什么可以始终有效。

如果您需要某种对象来确保指针不会指向已释放的内存，您将需要比引用或标准指针更智能的东西。

这就是为什么在使用指针和引用时需要非常小心所有权语义和生命周期管理。

Answer 3

在 C++ 中，引用主要用作函数的参数和返回类型。在参数的情况下，由于函数调用的性质，引用不能引用不再存在的对象（假设是单线程程序）。在返回值的情况下，应该限制自己返回生命周期比函数调用长的类成员变量，或者引用传递给函数的参数。

Answer 4

我的问题是我如何知道在初始化引用后该对象的内存尚未被释放/删除。

首先，没有任何方法可以检测内存位置是否已被释放/删除。这与它是否为 null 无关。对于指针也是如此。给定一个指针，您无法确保它指向有效的内存。您可以测试指针是否为空，但仅此而已。非空指针仍可能指向已释放的内存。或者它可能指向一些垃圾位置。

至于引用，这同样适用，因为您无法确定它是否引用了仍然有效的对象。然而，C++ 中不存在“空引用”这样的东西，因此不需要检查引用是否“为空”。

当然，可以编写创建看起来像“空引用”的代码，并且该代码将被编译。但它不会正确。根据C++语言标准，不能创建对null的引用。尝试这样做是未定义的行为。

归根结底，我不能凭信心接受这个建议，我需要更好的解释

更好的解释是这样的：“一个引用指向一个有效的对象，因为你将它设置为指向一个有效的对象”。你不必凭信心接受它。您只需查看创建引用的代码即可。它要么指向当时的有效对象，要么没有。如果没有，则代码不正确，应更改。

并且该引用仍然有效，因为您知道它将被使用，因此您已确保不会使其引用的对象无效。

真的就是这么简单。只要您不破坏它们指向的对象，引用就会保持有效。因此，在不再需要引用之前，不要销毁它指向的对象。

Answer 5

您需要保持变量的完整性 - 即，如果您知道函数作用域不会比您的引用/指针寿命更长，则仅将引用/指针传递给某个函数。

如果你去释放一些句柄，然后尝试使用所述引用，你将读取释放的内存。

Answer 6

因为当你到达那里时，你肯定已经做出了未定义的行为。让我解释一下:)

假设你有：

void fun(int& n);

现在，如果你传递类似的东西：

int* n = new int(5);
fun(*n); // no problems until now!

但是如果你执行以下操作：

int* n = new int(5);
...
delete n;
...
fun(*n); // passing a deleted memory!

当你到达fun时，你将取消引用*n，如果指针被删除，如上例所示。所以，没有办法，而且现在实际上必须有办法，因为假设有效参数就是引用的全部要点。

Answer 7

没有语法来检查引用是否有效。您可以测试指针是否为 NULL，但没有对引用进行有效/无效测试。当然，引用的对象可能会被一些有缺陷的代码释放或覆盖。同样的情况也适用于指针：如果非 NULL 指针指向已释放的对象，则无法测试它。

Answer 8

简而言之，它可能发生——但如果确实发生，你就会遇到严重的设计问题。您也没有真正的方法来检测它。答案是设计你的程序来防止它发生，而不是试图构建某种不会真正起作用的检查（因为它不能）。

Answer 9

我认为您可以从简单的并行性中受益：

• T & 类似于 T * const
• T const & 类似于 T const * const

引用的意图与 const 非常相似，它们带有含义，因此有助于编写更清晰的代码，但不提供不同的运行时行为。

现在回答您的问题：是的，引用可能为空或无效。您可以测试空引用（T& t = ; if (&t == 0)），但它不应该发生>>>根据合同，参考是有效的。

何时使用引用与指针？如果满足以下条件，请使用指针：

• 您希望能够更改被指向者
• 您希望表达可能的无效性

在任何其他情况下，请使用引用。

一些示例：

// Returns an object corresponding to the criteria
// or a special value if it cannot be found
Object* find(...); // returns 0 if fails

// Returns an object corresponding to the criteria
// or throw "NotFound" if it cannot be found
Object& find(...); // throw NotFound

传递参数：

void doSomething(Object* obj)
{
  if (obj) obj->doSomething();
}

void doSomething(Object& obj) { obj.do(); obj.something(); }

属性：

struct Foo
{
  int i;
  Bar* b; // No constructor, we need to initialize later on
};

class Foo
{
public:
  Foo(int i, Bar& b): i(i), b(b) {}
private:
  int i;
  Bar& b; // will always point to the same object, Foo not Default Constructible
};

class Other
{
public:
  Other(Bar& b): b(&b) {} // NEED to pass a valid object for init

  void swap(Other& rhs);  // NEED a pointer to be able to exchange

private:
  Bar* b;
};

在功能上，引用和指针扮演着完全相同的角色。这只是一个合同问题。不幸的是，如果您删除它们引用的对象，两者都会调用未定义行为，那里没有赢家；）

Answer 10

C++ 引用是别名。这样做的结果是，对指针的取消引用不一定发生在它们出现的地方，而是发生在它们被求值的地方。获取对对象的引用不会评估该对象，而是为其指定别名。使用引用来评估对象。 C++ 不能保证引用有效；如果是这样，所有 C++ 编译器都会崩溃。这样做的唯一方法是消除所有使用引用进行动态分配的可能性。实际上，假设引用是有效对象。由于 *NULL 未定义 &无效，因此对于 p = NULL，*p 也是未定义的。 C++ 的问题是 *p 将被有效地传递给函数，或者延迟其计算，直到实际使用引用为止。争论它是未定义的并不是提问者问题的重点。如果它是非法的，编译器将强制执行它，标准也是如此。据我所知，也没有。

int &r = *j; // aliases *j, but does not evaluate j
if(r > 0) // evaluates r ==> *j, resulting in dereference (evaluate j) at this line, not what some expect
  ;

1) 您可以测试对 NULL 指针别名的引用， &r 只是 &(无论 r 别名如何) (编辑)

2) 当传递“取消引用”指针 (*i) 作为引用参数时，取消引用不会不会在调用站点发生，它可能永远不会发生，因为它是一个引用（引用是别名，而不是评估）。这就是参考文献的优化。如果在调用站点对它们进行求值，则要么编译器插入了额外的代码，要么它将是按值调用并且性能低于指针。

是的，引用本身不是NULL，它是无效的，就像*NULL 是无效的一样。延迟解引用表达式的求值与声称不可能有无效引用不一致。

#include <iostream>

int fun(int & i) {
   std::cerr << &i << "\n";
   std::cerr << i << "\n"; // crash here
}

int main() {
   int * i = new int();
   i = 0;
   fun(*i); // Why not crash here? Because the deref doesn't happen here, inconsistent, but critical for performance of references
}

编辑：更改了我的示例，因为它被误解为测试参考的建议，而不是我想要演示的内容。我只想演示无效的引用。

Answer 11

我认为这“取决于”。我知道，这不是一个答案，但这确实取决于。我认为防御性编码是一个值得遵循的好习惯。现在，如果您的堆栈跟踪有 10 层深，并且跟踪下的任何故障都会导致整个操作失败，那么请务必在顶层进行检查，并让任何异常都上升到顶层。但如果您可以从向您传递空引用的人那里恢复，请在适当的情况下进行检查。根据我的经验，我必须将代码与其他公司整合在一起，检查（并记录）公共 API 级别的所有内容可以让您转移当集成未按预期进行时发生的指责。