C++中指针变量和引用变量之间有什么区别?




引用在本质上是什么它和指针到底有什么区别 (24)

如果你想变得非常迂腐,你可以用引号做一件事,你不能用指针做:延长临时对象的生命周期。 在C ++中,如果将const引用绑定到临时对象,则该对象的生命周期将成为引用的生命周期。

std::string s1 = "123";
std::string s2 = "456";

std::string s3_copy = s1 + s2;
const std::string& s3_reference = s1 + s2;

在此示例中,s3_copy复制作为串联结果的临时对象。 而s3_reference本质上成为临时对象。 它实际上是对临时对象的引用,该临时对象现在具有与引用相同的生命周期。

如果你在没有const情况下尝试这个,它将无法编译。 您不能将非const引用绑定到临时对象,也不能为此处获取其地址。

我知道引用是语法糖,因此代码更容易读写。

但有什么区别?

以下答案和链接摘要:

  1. 指针可以重新分配任意次数,而绑定后无法重新分配引用。
  2. 指针可以指向任何地方( NULL ),而引用总是指向一个对象。
  3. 您无法使用指针获取引用的地址。
  4. 没有“参考算术”(但是您可以获取引用所指向的对象的地址,并在其上执行指针算法,如&obj + 5 )。

澄清一个误解:

C ++标准非常谨慎,以避免规定编译器如何实现引用,但每个C ++编译器都将引用实现为指针。 也就是说,声明如下:

int &ri = i;

如果它没有完全优化 ,则分配与指针相同的存储量,并将i的地址放入该存储器中。

因此,指针和引用都使用相同数量的内存。

作为基本规则,

  • 使用函数参数和返回类型中的引用来提供有用的自记录接口。
  • 使用指针实现算法和数据结构。

有趣的读物:


  1. 可以重新分配指针:

    int x = 5;
    int y = 6;
    int *p;
    p =  &x;
    p = &y;
    *p = 10;
    assert(x == 5);
    assert(y == 10);
    

    引用不能,必须在初始化时分配:

    int x = 5;
    int y = 6;
    int &r = x;
    
  2. 指针在堆栈上有自己的内存地址和大小(x86上为4个字节),而引用共享相同的内存地址(使用原始变量),但也会占用堆栈上的一些空间。 由于引用与原始变量本身具有相同的地址,因此可以将引用视为同一变量的另一个名称。 注意:指针指向的内容可以在堆栈或堆上。 同上一个参考。 我在这个陈述中的主张并不是指针必须指向堆栈。 指针只是一个保存内存地址的变量。 此变量位于堆栈上。 由于引用在堆栈上有自己的空间,并且因为地址与它引用的变量相同。 更多关于堆栈与堆 。 这意味着编译器不会告诉您存在引用的真实地址。

    int x = 0;
    int &r = x;
    int *p = &x;
    int *p2 = &r;
    assert(p == p2);
    
  3. 您可以指向指向提供额外间接级别的指针的指针。 而引用仅提供一个间接层。

    int x = 0;
    int y = 0;
    int *p = &x;
    int *q = &y;
    int **pp = &p;
    pp = &q;//*pp = q
    **pp = 4;
    assert(y == 4);
    assert(x == 0);
    
  4. 指针可以直接指定为nullptr ,而引用则不能。 如果你足够努力,并且知道如何,你可以创建一个引用nullptr的地址。 同样,如果你足够努力,你可以引用一个指针,然后该引用可以包含nullptr

    int *p = nullptr;
    int &r = nullptr; <--- compiling error
    int &r = *p;  <--- likely no compiling error, especially if the nullptr is hidden behind a function call, yet it refers to a non-existent int at address 0
    
  5. 指针可以遍历数组,您可以使用++转到指针指向的下一个项目, + 4转到第5个元素。 无论指针指向的对象是什么大小。

  6. 需要使用*取消引用指针以访问它指向的内存位置,而可以直接使用引用。 指向类/结构的指针使用->来访问它的成员,而引用使用a .

  7. 指针是保存内存地址的变量。 无论引用如何实现,引用都具有与其引用的项相同的内存地址。

  8. 引用不能填充到数组中,而指针可以是(由用户@litb提及)

  9. Const引用可以绑定到临时值。 指针不能(不是没有一些间接):

    const int &x = int(12); //legal C++
    int *y = &int(12); //illegal to dereference a temporary.
    

    这使得const&更安全的用于参数列表等等。


它占用了多少空间并不重要,因为你实际上看不到它将占用的任何空间的任何副作用(不执行代码)。

另一方面,引用和指针之间的一个主要区别是分配给const引用的临时值存在,直到const引用超出范围。

例如:

class scope_test
{
public:
    ~scope_test() { printf("scope_test done!\n"); }
};

...

{
    const scope_test &test= scope_test();
    printf("in scope\n");
}

将打印:

in scope
scope_test done!

这是允许ScopeGuard工作的语言机制。


实际上,引用并不像指针。

编译器保持对变量的“引用”,将名称与内存地址相关联; 这是在编译时将任何变量名转换为内存地址的工作。

创建引用时,只告诉编译器为指针变量指定另一个名称; 这就是为什么引用不能“指向null”,因为变量不能,也不能。

指针是变量; 它们包含其他变量的地址,或者可以为null。 重要的是指针有一个值,而引用只有一个它正在引用的变量。

现在对实际代码的一些解释:

int a = 0;
int& b = a;

在这里,您不是要创建另一个指向a变量; 你只是在保存a值的内存内容中添加另一个名称。 此内存现在有两个名称, ab ,可以使用任一名称进行寻址。

void increment(int& n)
{
    n = n + 1;
}

int a;
increment(a);

调用函数时,编译器通常会为要复制的参数生成内存空间。 函数签名定义了应该创建的空格,并给出了应该用于这些空间的名称。 将参数声明为引用只是告诉编译器使用输入变量内存空间而不是在方法调用期间分配新的内存空间。 说你的函数将直接操作调用范围中声明的变量似乎很奇怪,但请记住,在执行编译代码时,没有更多的范围; 只有普通的平坦内存,你的功能代码可以操纵任何变量。

现在可能存在编译器在编译时可能无法知道引用的情况,例如使用extern变量时。 因此,引用可能会也可能不会被实现为底层代码中的指针。 但是在我给你的例子中,它很可能不会用指针实现。


指针和引用之间存在一个根本区别,我没有看到任何人提到过:引用在函数参数中启用了引用语法。指针虽然起初不可见,但它们不会:它们只提供按值传递的语义。这篇文章已经很好地描述了。

问候,&rzej


引用是另一个变量的别名,而指针保存变量的内存地址。引用通常用作函数参数,以便传递的对象不是副本而是对象本身。

    void fun(int &a, int &b); // A common usage of references.
    int a = 0;
    int &b = a; // b is an alias for a. Not so common to use. 

引用永远不能为NULL


在C ++中可以引用指针,但反过来不可能意味着指向引用的指针是不可能的。对指针的引用提供了更清晰的语法来修改指针。看看这个例子:

#include<iostream>
using namespace std;

void swap(char * &str1, char * &str2)
{
  char *temp = str1;
  str1 = str2;
  str2 = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap(str1, str2);
  cout<<"str1 is "<<str1<<endl;
  cout<<"str2 is "<<str2<<endl;
  return 0;
}

并考虑上述程序的C版本。在C中你必须使用指向指针(多个间接),它会导致混乱,程序可能看起来很复杂。

#include<stdio.h>
/* Swaps strings by swapping pointers */
void swap1(char **str1_ptr, char **str2_ptr)
{
  char *temp = *str1_ptr;
  *str1_ptr = *str2_ptr;
  *str2_ptr = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap1(&str1, &str2);
  printf("str1 is %s, str2 is %s", str1, str2);
  return 0;
}

有关指针引用的更多信息,请访问以下内容:

正如我所说,指向引用的指针是不可能的。尝试以下程序:

#include <iostream>
using namespace std;

int main()
{
   int x = 10;
   int *ptr = &x;
   int &*ptr1 = ptr;
}

虽然引用和指针都用于间接访问另一个值,但引用和指针之间存在两个重要区别。第一个是引用始终引用一个对象:在不初始化引用的情况下定义引用是错误的。赋值行为是第二​​个重要区别:赋值给引用会更改引用所绑定的对象; 它不会重新绑定对另一个对象的引用。初始化后,引用始终引用相同的基础对象。

考虑这两个程序片段。在第一个中,我们将一个指针指向另一个:

int ival = 1024, ival2 = 2048;
int *pi = &ival, *pi2 = &ival2;
pi = pi2;    // pi now points to ival2

在赋值后,ival,pi处理的对象保持不变。赋值会更改pi的值,使其指向不同的对象。现在考虑一个类似的程序,分配两个引用:

int &ri = ival, &ri2 = ival2;
ri = ri2;    // assigns ival2 to ival

此赋值更改ival,即ri引用的值,而不是引用本身。在赋值之后,两个引用仍然引用它们的原始对象,并且这些对象的值现在也是相同的。


你忘记了最重要的部分:

使用指针的成员访问->
使用引用的成员访问.

foo.bar 明显优于foo->bar ,就像vi 明显优于Emacs :-)


区别在于非常量指针变量(不要与指向常量的指针混淆)可能在程序执行期间的某个时间发生变化,需要使用指针语义(&,*)运算符,而初始化时可以设置引用only(这就是为什么你只能在构造函数初始化列表中设置它们,但不能以其他方式设置它们)并使用普通值访问语义。基本上引用了引用,以支持运算符重载,正如我在一本非常古老的书中所读到的那样。正如有人在这个线程中所说 - 指针可以设置为0或任何你想要的值。 0(NULL,nullptr)表示指针初始化为nothing。取消引用空指针是一个错误。但实际上指针可能包含一个不指向某个正确内存位置的值。引用依次尝试不允许用户初始化对无法引用的引用的引用,因为您始终为其提供正确类型的rvalue。虽然有很多方法可以将引用变量初始化为错误的内存位置 - 但最好不要深入研究细节。在机器级别,指针和引用均匀地工作 - 通过指针。让我们说必要的参考文献是语法糖。右值引用与此不同 - 它们自然是堆栈/堆对象。虽然有很多方法可以将引用变量初始化为错误的内存位置 - 但最好不要深入研究细节。在机器级别,指针和引用均匀地工作 - 通过指针。让我们说必要的参考文献是语法糖。右值引用与此不同 - 它们自然是堆栈/堆对象。虽然有很多方法可以将引用变量初始化为错误的内存位置 - 但最好不要深入研究细节。在机器级别,指针和引用均匀地工作 - 通过指针。让我们说必要的参考文献是语法糖。右值引用与此不同 - 它们自然是堆栈/堆对象。


我总是决定this从C ++核心指导原则:

当“无参数”是有效选项时,首选T *而不是T.


冒着混淆的风险,我想抛出一些输入,我确定它主要取决于编译器如何实现引用,但是在gcc的情况下,引用只能指向堆栈上的变量实际上并不正确,以此为例:

#include <iostream>
int main(int argc, char** argv) {
    // Create a string on the heap
    std::string *str_ptr = new std::string("THIS IS A STRING");
    // Dereference the string on the heap, and assign it to the reference
    std::string &str_ref = *str_ptr;
    // Not even a compiler warning! At least with gcc
    // Now lets try to print it's value!
    std::cout << str_ref << std::endl;
    // It works! Now lets print and compare actual memory addresses
    std::cout << str_ptr << " : " << &str_ref << std::endl;
    // Exactly the same, now remember to free the memory on the heap
    delete str_ptr;
}

哪个输出:

THIS IS A STRING
0xbb2070 : 0xbb2070

如果您注意到内存地址完全相同,则意味着引用成功指向堆上的变量!现在,如果你真的想变得怪异,这也有效:

int main(int argc, char** argv) {
    // In the actual new declaration let immediately de-reference and assign it to the reference
    std::string &str_ref = *(new std::string("THIS IS A STRING"));
    // Once again, it works! (at least in gcc)
    std::cout << str_ref;
    // Once again it prints fine, however we have no pointer to the heap allocation, right? So how do we free the space we just ignorantly created?
    delete &str_ref;
    /*And, it works, because we are taking the memory address that the reference is
    storing, and deleting it, which is all a pointer is doing, just we have to specify
    the address with '&' whereas a pointer does that implicitly, this is sort of like
    calling delete &(*str_ptr); (which also compiles and runs fine).*/
}

哪个输出:

THIS IS A STRING

因此引用是引擎盖下的一个指针,它们都只是存储一个内存地址,地址所指向的是无关紧要的,如果我调用std :: cout << str_ref;你会怎么想?在调用delete&str_ref之后?好吧,显然它编译得很好,但是在运行时导致分段错误,因为它不再指向有效变量,我们基本上有一个仍然存在的破坏引用(直到它超出范围),但是没用。

换句话说,引用只不过是一个指针,它将指针机制抽象出来,使其更安全,更容易使用(没有偶然的指针数学,没有混淆'。'和' - >'等),假设你不要像我上面的例子那样尝试任何废话;)

现在无论编译器如何处理引用,它总是会有一些指针,因为引用必须引用特定内存地址的特定变量才能使它按预期工作,没有解决这个问题(因此术语“参考”)。

唯一要记住引用的主要规则是它们必须在声明时定义(除了头中的引用外,在这种情况下它必须在构造函数中定义,在它包含的对象之后是构造它来定义它为时已晚)。

请记住,我上面的例子就是这样,展示参考资料的例子,你永远不会想要以这些方式使用参考!为了正确使用参考文献,这里已经有很多答案可以解决问题


我觉得还有另外一点,这里没有涉及。

与指针不同,引用在语法上等同于它们引用的对象,即可以应用于对象的任何操作都用于引用,并且具有完全相同的语法(例外当然是初始化)。

虽然这可能看起来很肤浅,但我相信这个属性对于许多C ++特性至关重要,例如:

  • 模板。由于模板参数是鸭类型,一种类型的语法属性是最重要的事情,所以往往是相同的模板可以既使用TT&
    (或者std::reference_wrapper<T>仍然依赖于隐式转换T&
    模板涵盖了两者T&T&&甚至更常见。

  • 左值。考虑语句str[0] = 'X';没有引用它只适用于c-strings(char* str)。通过引用返回字符允许用户定义的类具有相同的表示法。

  • 复制构造函数。从语法上讲,将对象传递给复制构造函数是有意义的,而不是指向对象的指针。但是,复制构造函数无法通过值获取对象 - 这将导致对同一复制构造函数的递归调用。这使引用成为唯一的选择。

  • 运算符重载。通过引用,可以将间接引入操作员调用 - 例如,operator+(const T& a, const T& b)同时保留相同的中缀符号。这也适用于常规的重载功能。

这些要点赋予了C ++和标准库的相当大的一部分,因此这是引用的一个主要属性。


这是基于本tutorial。写的内容更清楚:

>>> The address that locates a variable within memory is
    what we call a reference to that variable. (5th paragraph at page 63)

>>> The variable that stores the reference to another
    variable is what we call a pointer. (3rd paragraph at page 64)

简单地记住,

>>> reference stands for memory location
>>> pointer is a reference container (Maybe because we will use it for
several times, it is better to remember that reference.)

更重要的是,因为我们可以参考几乎任何指针教程,指针是指针算法支持的对象,它使指针类似于数组。

看下面的陈述,

int Tom(0);
int & alias_Tom = Tom;

alias_Tom可以理解为一个alias of a variable(具有不同的typedef,这是alias of a typeTom。也可以忘记这样的语句的术语是创建一个引用Tom


也许一些比喻会有所帮助; 在桌面屏幕空间的上下文中 -

  • 引用要求您指定实际窗口。
  • 指针需要屏幕上一块空间的位置,您可以确保它将包含该窗口类型的零个或多个实例。

此外,作为内联函数的参数的引用可以与指针不同地处理。

void increment(int *ptrint) { (*ptrint)++; }
void increment(int &refint) { refint++; }
void incptrtest()
{
    int testptr=0;
    increment(&testptr);
}
void increftest()
{
    int testref=0;
    increment(testref);
}

在内联指针版本1时,许多编译器实际上会强制写入内存(我们正在明确地获取地址)。但是,他们会将参考文献保留在更优化的寄存器中。

当然,对于没有内联的函数,指针和引用生成相同的代码,如果它们未被函数修改并返回,则通过值传递内在函数而不是引用更好。


该计划可能有助于理解问题的答案。这是引用“j”和指向变量“x”的指针“ptr”的简单程序。

#include<iostream>

using namespace std;

int main()
{
int *ptr=0, x=9; // pointer and variable declaration
ptr=&x; // pointer to variable "x"
int & j=x; // reference declaration; reference to variable "x"

cout << "x=" << x << endl;

cout << "&x=" << &x << endl;

cout << "j=" << j << endl;

cout << "&j=" << &j << endl;

cout << "*ptr=" << *ptr << endl;

cout << "ptr=" << ptr << endl;

cout << "&ptr=" << &ptr << endl;
    getch();
}

运行程序,看看输出,你会明白。

此外,请花10分钟观看此视频:https://www.youtube.com/watch?v=rlJrrGV0iOghttps://www.youtube.com/watch?v=rlJrrGV0iOg


引用和指针都可用于更改另一个函数内的一个函数的局部变量。当它们作为函数的参数传递或从函数返回时,它们都可用于保存大对象的复制,以获得效率增益。尽管有上述相似之处,但引用和指针之间存在以下差异。

引用不如指针强大

1)创建引用后,以后不能引用另一个引用; 它不能重新安置。这通常用指针完成。

2)引用不能为NULL。指针通常为NULL,表示它们没有指向任何有效的东西。

3)必须在声明时初始化引用。指针没有这样的限制

由于上述限制,C ++中的引用不能用于实现链接列表,树等数据结构。在Java中,引用没有上述限制,可用于实现所有数据结构。引用在Java中更强大,是Java不需要指针的主要原因。

参考文献更安全,更易于使用:

1)更安全:由于必须初始化引用,因此不太可能存在像野生指针这样的野蛮引用。仍然可以使引用不引用有效位置

2)易于使用:引用不需要解除引用操作符来访问该值。它们可以像普通变量一样使用。只有在申报时才需要'&'运营商。此外,可以使用点运算符('。')访问对象引用的成员,而不像需要箭头运算符( - >)来访问成员的指针。

与上述原因一起,很少有地方像复制构造函数参数,其中指针不能使用。必须使用引用传递复制构造函数中的参数。类似的引用必须用于重载某些运算符,如++


什么是C ++参考( 适用于C程序员

引用可以被认为是一个常量指针 (不要与指向常量值的指针混淆!)和自动间接,即编译器将为您应用*运算符。

必须使用非null值初始化所有引用,否则编译将失败。 获取引用的地址既不可能 - 地址运算符将返回引用值的地址 - 也不可能在引用上进行算术运算。

C程序员可能不喜欢C ++引用,因为当间接发生时,或者如果参数通过值或指针传递而不查看函数签名,它将不再是显而易见的。

C ++程序员可能不喜欢使用指针,因为它们被认为是不安全的 - 虽然引用并不比常量指针更安全,除了在最微不足道的情况下 - 缺乏自动间接的便利性并带有不同的语义内涵。

请考虑C ++ FAQ中的以下语句:

尽管引用通常是使用底层汇编语言中的地址实现的,但请不要将引用视为指向对象的有趣外观指针。 参考对象。 它不是指向对象的指针,也不是对象的副本。 这对象。

但如果参考确实是对象,那么怎么会有悬空引用呢? 在非托管语言中,引用不可能比指针更“安全” - 通常只是不能跨范围边界可靠地对值进行别名!

为什么我认为C ++引用很有用

来自C背景,C ++引用可能看起来像一个有点愚蠢的概念,但是在可能的情况下仍然应该使用它们而不是指针:自动间接方便的,并且在处理RAII时引用变得特别有用 - 但不是因为任何感知的安全性优点,而是因为它们使写作惯用代码不那么尴尬。

RAII是C ++的核心概念之一,但它与复制语义非常简单地交互。 通过引用传递对象避免了这些问题,因为不涉及复制。 如果语言中没有引用,则必须使用指针,这些指针使用起来比较麻烦,因此违反了语言设计原则,即最佳实践解决方案应该比替代方案更容易。


引用与指针非常相似,但它们经过精心设计,有助于优化编译器。

  • 设计引用使得编译器更容易跟踪哪个引用别名哪个变量。 两个主要特征非常重要:没有“参考算术”,也没有重新分配参考文献。 这些允许编译器在编译时找出哪些引用别名是哪些变量。
  • 允许引用引用没有内存地址的变量,例如编译器选择放入寄存器的变量。 如果你取一个局部变量的地址,编译器很难把它放在一个寄存器中。

举个例子:

void maybeModify(int& x); // may modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    // This function is designed to do something particularly troublesome
    // for optimizers. It will constantly call maybeModify on array[0] while
    // adding array[1] to array[2]..array[size-1]. There's no real reason to
    // do this, other than to demonstrate the power of references.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(array[0]);
        array[i] += array[1];
    }
}

优化编译器可能会意识到我们正在访问[0]和[1]相当多的一组。 它希望优化算法:

void hurtTheCompilersOptimizer(short size, int array[])
{
    // Do the same thing as above, but instead of accessing array[1]
    // all the time, access it once and store the result in a register,
    // which is much faster to do arithmetic with.
    register int a0 = a[0];
    register int a1 = a[1]; // access a[1] once
    for (int i = 2; i < (int)size; i++) {
        maybeModify(a0); // Give maybeModify a reference to a register
        array[i] += a1;  // Use the saved register value over and over
    }
    a[0] = a0; // Store the modified a[0] back into the array
}

为了进行这样的优化,需要证明在调用期间没有任何东西可以改变数组[1]。 这很容易做到。 我永远不会少于2,所以array [i]永远不会引用数组[1]。 maybeModify()被赋予a0作为参考(别名数组[0])。 因为没有“引用”算法,编译器只需要证明maybeModify永远不会得到x的地址,并且它已经证明没有任何改变数组[1]。

它还必须证明,当我们在a0中有一个临时寄存器副本时,未来的调用没有办法读/写[0]。 这通常是微不足道的,因为在很多情况下很明显,引用永远不会存储在像类实例这样的永久结构中。

现在用指针做同样的事情

void maybeModify(int* x); // May modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    // Same operation, only now with pointers, making the
    // optimization trickier.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(&(array[0]));
        array[i] += array[1];
    }
}

行为是一样的; 只是现在更难以证明maybeModify不会修改数组[1],因为我们已经给它一个指针; 这只猫已经不在了。 现在它必须做更加困难的证明:对maybeModify进行静态分析以证明它永远不会写入&x + 1.它还必须证明它永远不会保存可以引用数组[0]的指针,这只是太棘手了。

现代编译器在静态分析方面越来越好,但总是很好地帮助它们并使用引用。

当然,除非进行这种巧妙的优化,否则编译器确实会在需要时将引用转换为指针。

编辑:发布这个答案五年后,我发现了一个实际的技术差异,其中引用不同于查看相同寻址概念的不同方式。 引用可以以指针不能的方式修改临时对象的生命周期。

F createF(int argument);

void extending()
{
    const F& ref = createF(5);
    std::cout << ref.getArgument() << std::endl;
};

通常,临时对象(例如通过调用createF(5)创建的对象createF(5)在表达式的末尾被销毁。 但是,通过将该对象绑定到引用, ref ,C ++将延长该临时对象的生命周期,直到ref超出范围。


除了语法糖之外,引用是一个const指针( 不是指向const指针)。 您必须在声明引用变量时确定它所引用的内容,并且以后不能更改它。

更新:现在我再考虑一下,有一个重要的区别。

const指针的目标可以通过获取其地址并使用const转换来替换。

参考目标不能以任何方式替换UB。

这应该允许编译器对引用进行更多优化。


指针和引用之间存在非常重要的非技术差异:通过指针传递给函数的参数比通过非const引用传递给函数的参数更加明显。 例如:

void fn1(std::string s);
void fn2(const std::string& s);
void fn3(std::string& s);
void fn4(std::string* s);

void bar() {
    std::string x;
    fn1(x);  // Cannot modify x
    fn2(x);  // Cannot modify x (without const_cast)
    fn3(x);  // CAN modify x!
    fn4(&x); // Can modify x (but is obvious about it)
}

回到C,看起来像fn(x)只能通过值传递的调用,所以它肯定无法修改x;修改您需要传递指针的参数fn(&x)。因此,如果参数之前没有参数,则&您知道它不会被修改。 (相反,&意味着修改,不是真的,因为你有时必须通过const指针传递大的只读结构。)

有些人认为,在阅读代码时,这是一个非常有用的功能,指针参数应始终用于可修改的参数而不是非const引用,即使函数从不期望a nullptr。也就是说,那些人认为fn3()不应该允许像上面这样的功能签名。Google的C ++风格指南就是一个例子。


与流行的观点相反,可能有一个NULL引用。

int * p = NULL;
int & r = *p;
r = 1;  // crash! (if you're lucky)

当然,使用参考文件要困难得多 - 但是如果你管理它,你会撕掉你的头发试图找到它。 在C ++中,引用本身并不安全!

从技术上讲,这是一个无效的引用 ,而不是空引用。 C ++不支持空引用作为您可能在其他语言中找到的概念。 还有其他类型的无效引用。 任何无效引用都会引发未定义行为的幽灵,就像使用无效指针一样。

在分配给引用之前,实际错误是在NULL指针的解引用中。 但是我不知道任何编译器会在这种情况下产生任何错误 - 错误会传播到代码中的某个点。 这就是让这个问题如此阴险的原因。 大多数情况下,如果你取消引用一个NULL指针,你就会在那个位置崩溃,并且不需要太多的调试就可以搞清楚。

我上面的例子简短而且做作。 这是一个更真实的例子。

class MyClass
{
    ...
    virtual void DoSomething(int,int,int,int,int);
};

void Foo(const MyClass & bar)
{
    ...
    bar.DoSomething(i1,i2,i3,i4,i5);  // crash occurs here due to memory access violation - obvious why?
}

MyClass * GetInstance()
{
    if (somecondition)
        return NULL;
    ...
}

MyClass * p = GetInstance();
Foo(*p);

我想重申,获取空引用的唯一方法是通过格式错误的代码,一旦你拥有它,你就会得到未定义的行为。 检查空引用是没有意义的; 例如,您可以尝试if(&bar==NULL)...但编译器可能会优化语句不存在! 有效的引用永远不能为NULL,因此从编译器的视图来看,比较总是为false,并且可以将if子句作为死代码消除 - 这是未定义行为的本质。

避免麻烦的正确方法是避免取消引用NULL指针来创建引用。 这是实现这一目标的自动化方法。

template<typename T>
T& deref(T* p)
{
    if (p == NULL)
        throw std::invalid_argument(std::string("NULL reference"));
    return *p;
}

MyClass * p = GetInstance();
Foo(deref(p));

对于那些具有更好写作技巧的人来看这个问题,请参阅Jim Hyslop和Herb Sutter的Null References

有关解除引用空指针的危险的另一个示例,请参阅Raymond Chen 尝试将代码移植到另一个平台时暴露未定义的行为





c++-faq