Каковы различия между переменной указателя и ссылочной переменной в С++?

Я знаю, что ссылки - это синтаксический сахар, поэтому код легче читать и писать.

Но каковы различия?


Резюме из ответов и ссылок ниже:

  1. Указатель может быть повторно назначен любым количеством раз, в то время как ссылка не может быть повторно назначена после привязки.
  2. Указатели не могут указывать нигде (NULL), тогда как ссылка всегда относится к объекту.
  3. Вы не можете использовать адрес ссылки, как вы можете, указателями.
  4. Там нет "ссылочной арифметики" (но вы можете взять адрес объекта, на который указывает ссылка, и выполнить арифметику указателя на нем, как в &obj + 5).

Чтобы прояснить заблуждение:

Стандарт C++ очень осторожен, чтобы не диктовать, как компилятор может реализовать ссылки, но каждый C++ компилятор реализует ссылки в качестве указателей. То есть, декларация, такая как:

int &ri = i;

если он полностью не оптимизирован, выделяет тот же объем памяти, что и указатель, и помещает адрес i в это хранилище.

Таким образом, указатель и ссылка используют одинаковый объем памяти.

Как общее правило,

  • Используйте ссылки в функциональных параметрах и типах возврата для предоставления полезных и самодокументирующих интерфейсов.
  • Используйте указатели для реализации алгоритмов и структур данных.

Интересное чтение:

+3076
11 сент. '08 в 20:03
источник поделиться
41 ответ
  • 1
  • 2
  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. Указатель имеет свой собственный адрес и размер памяти в стеке (4 байта в x86), тогда как ссылка использует тот же адрес памяти (с исходной переменной), но также занимает некоторое место в стеке. Поскольку ссылка имеет тот же адрес, что и сама исходная переменная, можно с уверенностью рассматривать ссылку как другое имя для той же переменной. Примечание. То, на что указывает указатель, может быть в стеке или куче. Так же ссылка. Мое утверждение в этом утверждении не в том, что указатель должен указывать на стек. Указатель - это просто переменная, которая содержит адрес памяти. Эта переменная находится в стеке. Поскольку ссылка имеет свое собственное пространство в стеке, а адрес совпадает с переменной, на которую она ссылается. Подробнее о стеке и куче. Это означает, что существует реальный адрес ссылки, которую компилятор вам не скажет.

    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. Указатель необходимо разыменовать с помощью * для доступа к ячейке памяти, на которую он указывает, тогда как ссылку можно использовать напрямую. Указатель на класс/структуру использует -> для доступа к его членам, тогда как ссылка использует ..

  7. Указатель - это переменная, которая содержит адрес памяти. Независимо от того, как реализована ссылка, ссылка имеет тот же адрес памяти, что и элемент, на который она ссылается.

  8. Ссылки не могут быть вставлены в массив, тогда как указатели могут быть (упомянуты пользователем @litb)

  9. Const ссылки могут быть связаны с временными. Указатели не могут (не без некоторой косвенности):

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

    Это делает const& более безопасным для использования в списках аргументов и так далее.

+1596
11 сент. '08 в 20:08
источник

Что такое ссылка на С++ (для программистов C)

Ссылка может рассматриваться как постоянный указатель (не путать с указателем на постоянное значение!) с автоматической косвенностью, т.е. компилятор применит для вас оператор *.

Все ссылки должны быть инициализированы с ненулевым значением, иначе компиляция завершится с ошибкой. Невозможно получить адрес ссылки - вместо этого адресный оператор вернет адрес ссылочного значения - и не возможно сделать арифметику по ссылкам.

Программистам C могут не нравиться ссылки на С++, поскольку это не будет более очевидным, если произойдет косвенность или если аргумент передается по значению или указателем, не глядя на сигнатуры функций.

Программистам на С++ может не нравиться использование указателей, поскольку они считаются небезопасными, хотя ссылки на самом деле не являются более безопасными, чем постоянные указатели, за исключением самых тривиальных случаев - не имеют удобства автоматической косвенности и несут другую смысловую коннотацию.

Рассмотрим следующий оператор из Часто задаваемые вопросы по С++:

Даже если ссылка часто выполняется с использованием адреса в базовый язык ассемблера, пожалуйста, не думайте о ссылке в качестве смешно выглядящий указатель на объект. Ссылка - это объект. это не указатель на объект, ни копия объекта. Это объект.

Но если ссылка действительно была объектом, как могли быть оборванные ссылки? В неуправляемых языках невозможно, чтобы ссылки были "безопаснее", чем указатели, - как правило, это просто не способ достоверно псевдонимов значений границ области видимости!

Почему я считаю полезными ссылки на С++

Исходя из C-фона, ссылки на С++ могут выглядеть несколько глупой концепцией, но по-прежнему следует использовать их вместо указателей, где это возможно: автоматическая косвенность удобна, и ссылки становятся особенно полезными при работе с RAII - но не из-за каких-либо предполагаемых преимуществ безопасности, а скорее из-за того, что они делают буквенный идиоматический код менее неудобным.

RAII является одним из центральных понятий С++, но он взаимодействует нетривиально с семантикой копирования. Передача объектов по ссылке позволяет избежать этих проблем, поскольку не выполняется копирование. Если ссылки не присутствовали на этом языке, вам придется использовать указатели вместо этого, которые являются более громоздкими в использовании, нарушая, таким образом, принцип разработки языка, что решение с лучшей практикой должно быть проще, чем альтернативы.

+355
27 февр. '09 в 21:26
источник

Если вы хотите быть действительно педантичным, есть одна вещь, которую вы можете сделать со ссылкой, которую вы не можете сделать с помощью указателя: продлить время жизни временного объекта. В С++, если вы привязываете ссылку 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, он не должен компилироваться. Вы не можете привязывать неконстантную ссылку к временному объекту, и вы не можете принять его адрес в этом отношении.

+174
11 сент. '08 в 21:43
источник

Вопреки распространенному мнению, возможно иметь ссылку NULL.

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

Конечно, это намного сложнее сделать с ссылкой, но если вы справитесь с этим, вы будете рвать свои волосы, пытаясь найти его. Ссылки на С++ не являются неотъемлемо безопасными!

Технически это неверная ссылка, а не нулевая ссылка. С++ не поддерживает нулевые ссылки как концепцию, как вы можете найти на других языках. Существуют и другие недопустимые ссылки. Любая недопустимая ссылка повышает спектр undefined поведения, так же как использование недопустимого указателя.

Фактическая ошибка заключается в разыменовании указателя 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);

Я хочу повторить, что единственный способ получить нулевую ссылку - это неправильный код, и как только вы его получите, вы получаете поведение undefined. Это никогда имеет смысл проверить нулевую ссылку; например, вы можете попробовать if(&bar==NULL)..., но компилятор может оптимизировать утверждение из существования! Действительная ссылка никогда не может быть NULL, поэтому из представления компилятора сравнение всегда ложно, и можно свободно исключить предложение if как мертвый код - это сущность поведения undefined.

Правильный способ избежать неприятностей состоит в том, чтобы избежать разыменования указателя 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));

Для более старого взгляда на эту проблему у кого-то, у кого лучшие навыки написания, см. Null References от Jim Hyslop и Herb Sutter.

Для другого примера опасности разыменования нулевого указателя см. Отображение поведения undefined при попытке переноса кода на другую платформу Раймонда Чен.

+119
11 сент. '08 в 21:06
источник

Помимо синтаксического сахара, ссылка является указателем const (не указателем на const). Вы должны установить, к чему это относится, когда вы объявляете ссылочную переменную, и вы не можете изменить ее позже.

Обновление: теперь, когда я думаю об этом еще, есть важная разница.

Целевая константа-указатель может быть заменена принятием своего адреса и использованием const-конста.

Целевая ссылка не может быть заменена каким-либо образом ниже UB.

Это должно позволить компилятору сделать большую оптимизацию по ссылке.

+117
11 сент. '08 в 20:07
источник

Вы забыли самую важную часть:

член-доступ с указателями использует ->
член-доступ со ссылками использует .

foo.bar явно превосходит foo->bar таким же образом, что vi явно превосходит Emacs: -)

+109
11 сент. '08 в 22:10
источник

Ссылки очень похожи на указатели, но они специально созданы, чтобы помочь оптимизировать компиляторы.

  • Ссылки разработаны таким образом, что компилятор существенно упрощает отслеживание ссылочных псевдонимов, которые являются переменными. Две важные особенности очень важны: нет "ссылочной арифметики" и не переназначения ссылок. Они позволяют компилятору выяснить, какие ссылки содержат псевдониму, какие переменные во время компиляции.
  • Ссылки могут ссылаться на переменные, которые не имеют адресов памяти, например, которые компилятор выбирает для ввода в регистры. Если вы берете адрес локальной переменной, компилятор очень сложно поместить его в регистр.

В качестве примера:

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 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 как ссылка (aliasing array [0]). Поскольку нет "ссылочной" арифметики, компилятор просто должен доказать, что возможноModify никогда не получает адрес x, и он доказал, что ничто не изменяет массив [1].

Он также должен доказать, что нет способа, которым будущий вызов мог бы читать/писать [0], в то время как у нас есть временная копия реестра в a0. Это часто тривиально доказывать, потому что во многих случаях очевидно, что эта ссылка никогда не хранится в постоянной структуре, такой как экземпляр класса.

Теперь сделайте то же самое с указателями

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];
    }
}

Поведение такое же; только сейчас гораздо сложнее доказать, что, возможно ,Modify никогда не модифицирует массив [1], потому что мы уже указали ему указатель; кошка вышла из сумки. Теперь он должен сделать гораздо более сложное доказательство: статический анализ mayModify, чтобы доказать, что он никогда не пишет в & x + 1. Он также должен доказать, что он никогда не избавляет от указателя, который может ссылаться на массив [0], который просто как сложно.

Современные компиляторы становятся все лучше и лучше при статическом анализе, но всегда приятно помочь им и использовать ссылки.

Конечно, за исключением таких умных оптимизаций, компиляторы действительно будут обращаться к ссылкам в указатели, когда это необходимо.

EDIT: через пять лет после публикации этого ответа я нашел фактическую техническую разницу, где ссылки отличаются от другого способа взглянуть на ту же концепцию адресации. Ссылки могут изменять продолжительность жизни временных объектов таким образом, что указатели не могут.

F createF(int argument);

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

Обычно в конце выражения уничтожаются обычно временные объекты, такие как созданный вызовом createF(5). Однако, связывая этот объект с ссылкой, ref, C++ продлит срок службы этого временного объекта, пока ref не выйдет за рамки.

+65
01 сент. '13 в 3:44
источник

Собственно, ссылка не похожа на указатель.

Компилятор сохраняет "ссылки" на переменные, связывая имя с адресом памяти; что его задача перевести любое имя переменной на адрес памяти при компиляции.

Когда вы создаете ссылку, вы сообщаете компилятору, что вы назначаете другое имя переменной указателя; почему ссылки не могут "указывать на null", потому что переменная не может быть, а не быть.

Указатели являются переменными; они содержат адрес какой-либо другой переменной или могут быть нулевыми. Важно то, что указатель имеет значение, а ссылка имеет только переменную, на которую ссылается.

Теперь некоторое объяснение реального кода:

int a = 0;
int& b = a;

Здесь вы не создаете другую переменную, которая указывает на a; вы просто добавляете другое имя в содержимое памяти, содержащее значение a. Эта память теперь имеет два имени: a и b, и ее можно решить с помощью любого имени.

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

int a;
increment(a);

При вызове функции компилятор обычно генерирует пространства памяти для аргументов, подлежащих копированию. Функциональная подпись определяет пространства, которые должны быть созданы, и дает имя, которое должно использоваться для этих пространств. Объявление параметра в качестве ссылки просто указывает компилятору использовать пространство с переменной входной переменной вместо выделения нового пространства памяти во время вызова метода. Может показаться странным сказать, что ваша функция будет непосредственно манипулировать переменной, объявленной в области вызова, но помните, что при выполнении скомпилированного кода больше нет области видимости; есть просто плоская память, и ваш функциональный код может манипулировать любыми переменными.

Теперь могут быть случаи, когда ваш компилятор может не знать ссылку при компиляции, например, при использовании переменной extern. Таким образом, ссылка может быть или не быть реализована как указатель в базовом коде. Но в примерах, которые я вам дал, он скорее всего не будет реализован с помощью указателя.

+63
19 сент. '08 в 12:23
источник

Ссылка никогда не может быть NULL.

+39
11 сент. '08 в 20:12
источник

Хотя обе ссылки и указатели используются для косвенного доступа к другому значению, существуют два важных различия между ссылками и указателями. Во-первых, ссылка всегда ссылается на объект: ошибка заключается в определении ссылки без ее инициализации. Поведение присвоения - это второе важное различие: Присвоение ссылки заменяет объект, к которому привязана ссылка; он не перепроверяет ссылку на другой объект. После инициализации ссылка всегда ссылается на один и тот же базовый объект.

Рассмотрим эти два фрагмента программы. В первом мы назначаем один указатель другому:

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, а не сама ссылка. После назначения две ссылки по-прежнему относятся к их исходным объектам, и значение этих объектов теперь тоже самое.

+33
20 мая '11 в 19:26
источник

Существует семантическая разница, которая может казаться эзотерической, если вы не знакомы с изучением компьютерных языков абстрактным или даже академическим способом.

На самом высоком уровне идея ссылок заключается в том, что они являются прозрачными "псевдонимами". Ваш компьютер может использовать адрес, чтобы заставить их работать, но вы не должны беспокоиться об этом: вы должны думать о них как о "просто другом имени" для существующего объекта, и этот синтаксис отражает это. Они более строгие, чем указатели, поэтому ваш компилятор может более надежно предупредить вас, когда вы собираетесь создать обвисшую ссылку, чем когда вы собираетесь создать свисающий указатель.

Кроме того, есть, конечно, некоторые практические различия между указателями и ссылками. Синтаксис для их использования явно отличается, и вы не можете "пересаживать" ссылки, ссылаться на небытие или ссылаться на ссылки.

+28
29 окт. '14 в 17:17
источник

Ссылка является псевдонимом для другой переменной, тогда как указатель содержит адрес памяти переменной. Ссылки обычно используются в качестве параметров функции, так что передаваемый объект не является копией, а сам объект.

    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. 
+24
01 янв. '13 в 17:45
источник

Неважно, сколько места оно занимает, так как вы не можете увидеть какой-либо побочный эффект (без выполнения кода) любого пространства, в котором оно будет занимать.

С другой стороны, одно существенное различие между ссылками и указателями заключается в том, что временные ссылки, назначенные для ссылок на константу, живут до тех пор, пока ссылка на 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 работать.

+18
12 сент. '08 в 23:27
источник

Ссылка не является другим именем, данным некоторой памяти. Это неизменный указатель, который автоматически отключается при использовании. В основном это сводится к:

int& j = i;

Он внутренне становится

int* const j = &i;
+18
26 февр. '13 в 5:20
источник

Это основано на 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 type) Tom. Также можно забыть терминологию такого утверждения, чтобы создать ссылку Tom.

+18
13 янв. '14 в 13:14
источник

Я использую ссылки, если мне не нужно ни одного из них:

  • Нулевые указатели могут использоваться как часовое значение, часто дешевый способ избежать перегрузки или использования функций bool.

  • Вы можете сделать арифметику на указателе. Например, p += offset;

+15
12 сент. '08 в 13:41
источник

Ссылка на указатель возможна в С++, но обратное невозможно, поскольку указатель на ссылку невозможен. Ссылка на указатель обеспечивает более чистый синтаксис для изменения указателя. Посмотрите на этот пример:

#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;
}
+15
09 февр. '15 в 13:17
источник

Существует одно фундаментальное различие между указателями и ссылками, которые я не видел никого, о которых упоминалось: ссылки позволяют использовать семантику pass-by-reference в аргументах функции. Указатели, хотя сначала это не видно, нет: они предоставляют только семантику pass-by-value. Это было очень хорошо описано в этой статье.

С уважением, & Амп; rzej

+14
06 февр. '12 в 8:59
источник

Прямой ответ

Что такое ссылка в C++? Некоторый конкретный экземпляр типа, который не является типом объекта.

Что такое указатель в C++? Некоторый конкретный экземпляр типа, который является типом объекта.

Из определения ISO C++ типа объекта:

Тип объекта - это (возможно, квалифицированный cv-) тип, который не является типом функции, не ссылочным типом и не cv void.

Может быть важно знать, что тип объекта является категорией верхнего уровня юниверса типа в C++. Справочник также является категорией верхнего уровня. Но указатель - нет.

Указатели и ссылки упоминаются вместе в контексте составного типа. Это в основном связано с природой синтаксиса объявления, унаследованного от (и расширенного) C, который не имеет ссылок. (Кроме того, начиная с C++ 11 существует более одного вида деклараторов ссылок, в то время как указатели все еще "единообразны": & + && против *.) Таким образом, составление языка, специфичного для "расширения" с подобным стилем C в этом контексте несколько разумно. (Я по-прежнему буду утверждать, что синтаксис деклараторов сильно тратит синтаксическую выразительность, расстраивает как пользователей, так и реализации. Таким образом, все они не могут быть встроены в новый языковой дизайн. Это совершенно другая тема о дизайне PL, хотя.)

В противном случае неважно, что указатели можно квалифицировать как типы определенных типов со ссылками вместе. Они просто имеют слишком мало общих свойств, кроме синтаксического сходства, поэтому в большинстве случаев нет необходимости их объединять.

Обратите внимание, что приведенные выше утверждения упоминают только "указатели" и "ссылки" как типы. Есть несколько интересных вопросов об их экземплярах (например, переменные). Там также приходит слишком много заблуждений.

Различия категорий верхнего уровня уже могут выявить множество конкретных различий, не связанных напрямую с указателями:

  • Типы объектов могут иметь квалификаторы верхнего уровня cv. Ссылки не могут.
  • Переменная типов объектов занимает память в соответствии с семантикой абстрактной машины. Ссылка не обязательно должна занимать хранилище (подробности см. в разделе о заблуждениях ниже).
  • ...

Еще несколько специальных правил для ссылок:

  • Составные объявления являются более строгими в отношении ссылок.
  • Ссылки могут свернуть.
    • Специальные правила для параметров && (такие как "пересылка ссылок"), основанные на свертывании ссылок во время вывода параметров шаблона, позволяют "совершенную пересылку" параметров.
  • Ссылки имеют специальные правила при инициализации. Время жизни переменной, объявленной как ссылочный тип, может отличаться от обычных объектов через расширение.
    • Кстати, некоторые другие контексты, такие как инициализация с участием std::initializer_list, следуют некоторым подобным правилам продления срока службы эталона. Это еще одна банка червей.
  • ...

Заблуждения

Синтаксический сахар

Я знаю, что ссылки являются синтаксическим сахаром, поэтому код легче читать и писать.

Технически это совершенно неправильно. Ссылки не являются синтаксическим сахаром других функций в C++, потому что они не могут быть точно заменены другими функциями без каких-либо семантических различий.

(Точно так же лямбда-выражения не являются синтаксическим сахаром каких-либо других функций в C++, потому что они не могут быть точно смоделированы с "неопределенными" свойствами, такими как порядок объявления захваченных переменных, что может быть важно, потому что порядок инициализации таких переменных может быть значительным.)

C++ имеет только несколько видов синтаксических сахаров в этом строгом смысле. Одним из экземпляров является (унаследованный от C) встроенный (не перегруженный) оператор [], который определен точно с такими же семантическими свойствами конкретных форм комбинации, что и встроенный оператор унарный * и двоичный +.

хранения Таким образом, указатель и ссылка используют одинаковый объем памяти.

Вышеприведенное утверждение просто неверно. Чтобы избежать таких заблуждений, посмотрите вместо этого на правила ISO C++:

Из [intro.object]/1:

... Объект занимает область хранения в период его строительства, на протяжении всей его жизни и в период его разрушения....

Из [dcl.ref]/4:

Не указано, требуется ли ссылка для хранения.

Обратите внимание, что это семантические свойства.

Прагматика

Даже если указатели недостаточно квалифицированы, чтобы их можно было объединить со ссылками в смысле языкового дизайна, все же есть некоторые аргументы, делающие спорным выбор между ними в некоторых других контекстах, например, при выборе типов параметров.

Но это еще не все. Я имею в виду, есть больше вещей, чем указатели против ссылок, которые вы должны учитывать.

Если вам не нужно придерживаться такого чрезмерного выбора, в большинстве случаев ответ будет коротким: вам не нужно использовать указатели, поэтому вы не должны. Указатели, как правило, достаточно плохие, потому что они подразумевают слишком много вещей, которых вы не ожидаете, и они будут полагаться на слишком много неявных предположений, подрывающих удобство сопровождения и (даже) переносимость кода. Излишне полагаться на указатели - это определенно плохой стиль, и его следует избегать в смысле современного C++. Пересмотрите свою цель, и вы, наконец, обнаружите, что указатель является функцией последних видов в большинстве случаев.

  • Иногда языковые правила явно требуют использования определенных типов. Если вы хотите использовать эти функции, соблюдайте правила.
    • Конструкторам копирования требуются определенные типы ссылочного типа cv- & в качестве первого типа параметра. (И обычно это должно быть const).
    • Конструкторы перемещения требуют определенных типов ссылочного типа cv- && в качестве первого типа параметра. (И, как правило, не должно быть определителей.)
    • Конкретные перегрузки операторов требуют ссылочных или не ссылочных типов. Например:
      • Перегруженный operator= в качестве специальных функций-членов требует ссылочных типов, аналогичных 1-му параметру конструкторов копирования/перемещения.
      • Постфиксу ++ требуется пустышка int.
      • ...
  • Если вы знаете, что передачи по значению (т.е. с использованием нереферентных типов) достаточно, используйте его напрямую, особенно при использовании реализации, поддерживающей C++ 17 обязательное исключение копирования. (Предупреждение: однако исчерпывающе обоснование необходимости может быть очень сложным.)
  • Если вы хотите использовать некоторые маркеры с правами собственности, используйте умные указатели, такие как unique_ptr и shared_ptr (или даже сами доморощенные, если вы хотите, чтобы они были непрозрачными), а не необработанные указатели.
  • Если вы выполняете некоторые итерации по диапазону, используйте итераторы (или некоторые диапазоны, которые еще не предоставлены стандартной библиотекой), а не необработанные указатели, если вы не уверены, что необработанные указатели будут работать лучше (например, для меньших зависимостей заголовка) в очень специфических случаев.
  • Если вы знаете, что передачи по значению достаточно, и вам нужна некоторая явная обнуляемая семантика, используйте обертку, например std::optional, а не необработанные указатели.
  • Если вы знаете, что передача по значению не идеальна по вышеуказанным причинам, и вам не нужна семантика, допускающая обнуляемость, используйте {lvalue, rvalue, forwarding} -references.
  • Даже если вам нужна семантика, такая как традиционный указатель, часто есть что-то более подходящее, например, observer_ptr в Library Fundamental TS.

Единственные исключения нельзя обойти на текущем языке:

  • Когда вы реализуете умные указатели выше, вам, возможно, придется иметь дело с необработанными указателями.
  • Для конкретных процедур взаимодействия языков требуются указатели, например operator new. (Тем не менее, cv- void* все еще довольно отличается и безопаснее по сравнению с обычными объектными указателями, потому что он исключает неожиданную арифметику указателей, если только вы не полагаетесь на какое-то несоответствующее расширение на void*, например на GNU.)
  • Указатели на функции могут быть преобразованы из лямбда-выражений без перехватов, а ссылки на функции - нет. Вы должны использовать указатели функций в неуниверсальном коде для таких случаев, даже если вы намеренно не хотите обнуляемых значений.

Таким образом, на практике ответ так очевиден: если есть сомнения, избегайте указателей. Вы должны использовать указатели только тогда, когда есть очень явные причины, по которым нет ничего более подходящего. За исключением нескольких исключительных случаев, упомянутых выше, такой выбор почти всегда не является чисто C++ -специфичным (но, скорее всего, будет зависеть от языковой реализации). Такими примерами могут быть:

  • Вы должны использовать API старого стиля (C).
  • Вы должны соответствовать требованиям ABI определенных реализаций C++.
  • Вы должны взаимодействовать во время выполнения с различными языковыми реализациями (включая различные сборки, языковую среду выполнения и FFI некоторых высокоуровневых клиентских языков) на основе предположений о конкретных реализациях.
  • Вы должны повысить эффективность перевода (компиляция и компоновка) в некоторых крайних случаях.
  • В некоторых крайних случаях вы должны избегать раздувания символов.

Предостережения в отношении языковой нейтральности

Если вы пришли посмотреть на вопрос через какой-то результат поиска Google (не относится только к C++), скорее всего, это неправильное место.

Ссылки в C++ довольно "странные", так как они по сути не первоклассные: они будут рассматриваться как объекты или функции, на которые ссылаются, поэтому у них нет шансов поддержать какой-то первоклассный такие операции, как левый операнд оператора доступа к элементу независимо от типа упомянутого объекта. Другие языки могут иметь или не иметь аналогичные ограничения на свои ссылки.

Ссылки в C++, скорее всего, не сохранят значения на разных языках. Например, ссылки в общем не подразумевают ненулевые свойства для значений, как они в C++, поэтому такие допущения могут не работать в некоторых других языках (и вы легко найдете контрпримеры, например, Java, С#,...).

В целом ссылки на разные языки программирования могут быть общими, но оставим это для некоторых других вопросов в SO.

(Дополнительное примечание: вопрос может быть важен раньше, чем участвуют любые "C-подобные" языки, например, ALGOL 68 против PL/I.)

+14
17 февр. '19 в 7:37
источник

Рискуя добавить в замешательство, я хочу добавить некоторые данные, я уверен, что это в основном зависит от того, как компилятор реализует ссылки, но в случае 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 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? Ну, очевидно, что он компилируется отлично, но вызывает ошибку сегментации во время выполнения, поскольку он больше не указывает на допустимую переменную, мы по существу имеем сломанную ссылку, которая все еще существует (пока она не выпадает из области), но бесполезна.

Другими словами, ссылка - это не что иное, как указатель, у которого механики указателей отвлечены, что делает его более безопасным и простым в использовании (без случайной математики указателя, без смешивания "." и "- > " и т.д.)., предполагая, что вы не пробовали какую-либо глупость, как мои примеры выше;)

Теперь независимо от того, как компилятор обрабатывает ссылки, он будет всегда иметь какой-то указатель под капотом, потому что ссылка должна ссылаться к определенной переменной в определенном адресе памяти, чтобы она работала так, как ожидалось, не обойти это (отсюда и термин "ссылка" ).

Единственное важное правило, которое важно запомнить с помощью ссылок, заключается в том, что они должны быть определены во время объявления (за исключением ссылки в заголовке, в этом случае он должен быть определен в конструкторе, после того, как объект содержащийся в построении, слишком поздно, чтобы определить его).

Помните, что приведенные выше примеры - это примеры, демонстрирующие, что такое ссылка, вы никогда не захотите использовать ссылку в этих целях! Для правильного использования ссылки здесь уже много ответов, которые поражают гвоздь на голове

+13
14 окт. '14 в 21:38
источник

Другое отличие состоит в том, что у вас могут быть указатели на тип void (и это означает указатель на что-либо), но ссылки на void запрещены.

int a;
void * p = &a; // ok
void & p = a;  //  forbidden

Я не могу сказать, что я действительно доволен этой особой разницей. Я бы предпочел, чтобы это разрешалось со ссылкой на что-либо с адресом и в противном случае такое же поведение для ссылок. Это позволило бы определить некоторые эквиваленты функций библиотеки C, таких как memcpy, используя ссылки.

+12
29 янв. '10 в 15:15
источник

Обе ссылки и указатели могут использоваться для изменения локальных переменных одной функции внутри другой функции. Оба они могут также использоваться для сохранения копирования больших объектов при передаче в качестве аргументов функций или возврата из функций, чтобы получить коэффициент полезного действия. Несмотря на вышеописанные сходства, существуют следующие различия между ссылками и указателями.

Ссылки менее мощные, чем указатели

1) После создания ссылки впоследствии нельзя ссылаться на другой объект; он не может быть пересмотрен. Это часто делается с указателями.

2) Ссылки не могут быть NULL. Указатели часто делают NULL, чтобы указать, что они не указывают на какую-либо действительную вещь.

3) При объявлении эта ссылка должна быть инициализирована. Нет такого ограничения с указателями

Из-за вышеуказанных ограничений ссылки на С++ не могут использоваться для реализации структур данных, таких как Linked List, Tree и т.д. В Java ссылки не имеют ограничений и могут использоваться для реализации всех структур данных. Ссылки, более мощные в Java, являются основной причиной, по которой Java не нуждается в указателях.

Ссылки более безопасны и просты в использовании:

1) Безопаснее: поскольку ссылки должны быть инициализированы, дикие ссылки, такие как дикие указатели, вряд ли будут существовать. По-прежнему возможно иметь ссылки, которые не относятся к допустимому местоположению

2) Прост в использовании: для доступа к значению не требуется оператор разыменования. Они могут использоваться как обычные переменные. "& Амп; оператор нужен только во время объявления. Кроме того, к элементам ссылки объекта можно обращаться с помощью оператора точки ('.), В отличие от указателей, в которых для доступа к элементам необходим оператор стрелки (- > ).

Вместе с вышеупомянутыми причинами существует несколько мест, таких как аргумент конструктора копирования, где указатель не может использоваться. Ссылка должна использоваться, чтобы передать аргумент в конструкторе копирования. Аналогично ссылки должны использоваться для перегрузки некоторых операторов, таких как ++.

+12
02 дек. '15 в 9:41
источник

Кроме того, ссылка, которая является параметром для функции, которая является встроенной, может обрабатываться иначе, чем указатель.

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

Многие компиляторы при встраивании указателя версии один на самом деле вынуждают запись в память (мы берем адрес явно). Тем не менее, они оставят ссылку в регистре, который является более оптимальным.

Конечно, для неинтегрированных функций указатель и ссылка генерируют один и тот же код, и всегда лучше передавать intrinsics по значению, чем по ссылке, если они не изменяются и не возвращаются функцией.

+11
15 окт. '09 в 1:57
источник

Еще одно интересное использование ссылок - предоставить аргумент по умолчанию для пользовательского типа:

class UDT
{
public:
   UDT() : val_d(33) {};
   UDT(int val) : val_d(val) {};
   virtual ~UDT() {};
private:
   int val_d;
};

class UDT_Derived : public UDT
{
public:
   UDT_Derived() : UDT() {};
   virtual ~UDT_Derived() {};
};

class Behavior
{
public:
   Behavior(
      const UDT &udt = UDT()
   )  {};
};

int main()
{
   Behavior b; // take default

   UDT u(88);
   Behavior c(u);

   UDT_Derived ud;
   Behavior d(ud);

   return 1;
}

По умолчанию используется ссылка "привязка константы к временному" аспекту ссылок.

+10
12 сент. '08 в 17:59
источник

Эта программа может помочь в понимании ответа на вопрос. Это простая программа ссылки "j" и указатель "ptr", указывающий на переменную "x".

#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=rlJrrGV0iOg

+10
15 мар. '13 в 3:03
источник

Я чувствую, что есть еще один момент, который здесь не был рассмотрен.

В отличие от указателей ссылки ссылаются на синтаксически эквивалентный на объект, к которому они ссылаются, то есть любая операция, которая может быть применена к объекту, работает для ссылки и с тем же синтаксисом (исключение конечно, инициализация).

Хотя это может показаться поверхностным, я считаю, что это свойство имеет решающее значение для ряда функций С++, например:

  • Шаблоны. Поскольку параметры шаблона заданы в стиле утка, все синтаксические свойства типа имеют значение, поэтому часто один и тот же шаблон можно использовать как с T, так и с T&.
    (или std::reference_wrapper<T>, который все еще полагается на неявный листинг до T&)
    Шаблоны, охватывающие как T&, так и T&&, еще более распространены.

  • Lvalues. Рассмотрим оператор str[0] = 'X'; Без ссылок он будет работать только для c-строк (char* str). Возврат символа по ссылке позволяет пользовательским классам иметь одну и ту же нотацию.

  • Скопируйте конструкторы. Синтаксически имеет смысл передавать объекты для копирования конструкторов, а не указатели на объекты. Но конструктор копирования просто не может взять объект по значению - это приведет к рекурсивному вызову того же конструктора копий. Это оставляет ссылки как единственный вариант здесь.

  • Оператор перегружает. С помощью ссылок можно ввести косвенный вызов оператора - скажем, operator+(const T& a, const T& b), сохранив при этом одну и ту же инфиксную нотацию. Это также работает для регулярных перегруженных функций.

Эти точки дают значительную часть С++ и стандартной библиотеки, поэтому это довольно важное свойство ссылок.

+9
06 июл. '17 в 19:48
источник

Возможно, некоторые метафоры помогут; В контексте экрана рабочего стола -

  • Ссылка требует указания фактического окна.
  • Указатель требует расположения части пространства на экране, которое, как вы уверяете, будет содержать ноль или более экземпляров этого типа окна.
+8
27 дек. '14 в 13:00
источник

Как указатель, ссылка является псевдонимом для объекта, обычно реализован для хранения машинного адреса объекта и не налагать накладные расходы по сравнению с указателями, но он отличается от указатель в том, что:

• Вы получаете доступ к ссылке с точно таким же синтаксисом, что и имя объект.

• Ссылка всегда ссылается на объект, для которого он был инициализирован.

• Нет нулевой ссылки, и мы можем предположить, что ссылка относится к объекту.

Основное использование ссылок - для указания аргументов и возврата значения для функций вообще и для перегруженных операторов в частности.

Например:

template<class T>
class vector {
T∗ elem;
// ...
public:
T& operator[](int i) { return elem[i]; } // return reference to element
const T& operator[](int i) const { return elem[i]; } // return reference to const element
void push_back(const T& a); // pass element to be added by reference
// ...
};
void f(const vector<double>& v)
{
double d1 = v[1]; // copy the value of the double referred to by v.operator[](1) into d1
v[2] = 7; // place 7 in the double referred to by the result of v.operator[](2)
v.push_back(d1); // give push_back() a reference to d1 to wor k with
}
+8
02 дек. '17 в 17:30

Существует очень важное техническое различие non- между указателями и ссылками: аргумент, передаваемый в функцию указателем, гораздо более заметен, чем аргумент, передаваемый в функцию посредством ссылки non- 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 указателя.)

Некоторые утверждают, что это такая полезная функция при чтении кода, что параметры указателя всегда следует использовать для изменяемых параметров, а не non- const ссылки, даже если функция не ожидает nullptr. То есть эти люди утверждают, что подписи функций, такие как fn3() выше, не должны быть разрешены. Руководящие принципы стиля Google C++ являются примером этого.

+8
02 нояб. '17 в 11:16
источник

Разница между указателем и ссылкой

Указатель может быть инициализирован равным 0, а ссылка не указана. Фактически, ссылка должна также ссылаться на объект, но указатель может быть нулевым указателем:

int* p = 0;

Но мы не можем иметь int& p = 0;, а также int& p=5 ;.

На самом деле, чтобы сделать это правильно, мы должны были объявить и определить объект в первом, тогда мы сможем сделать ссылку на этот объект, поэтому правильная реализация предыдущего кода будет:

Int x = 0;
Int y = 5;
Int& p = x;
Int& p1 = y;

Еще один важный момент заключается в том, что мы можем сделать объявление указателя без инициализации, однако в случае ссылки такая вещь не может быть сделана, которая должна всегда ссылаться на переменную или объект. Однако такое использование указателя является рискованным, поэтому мы обычно проверяем, указывает ли указатель на что-то или нет. В случае ссылки такая проверка не требуется, поскольку мы уже знаем, что ссылка на объект во время объявления является обязательной.

Еще одно отличие заключается в том, что указатель может указывать на другой объект, однако ссылка всегда ссылается на один и тот же объект, поэтому возьмите этот пример:

Int a = 6, b = 5;
Int& rf = a;

Cout << rf << endl; // The result we will get is 6, because rf is referencing to the value of a.

rf = b;
cout << a << endl; // The result will be 5 because the value of b now will be stored into the address of a so the former value of a will be erased

Другой момент: когда у нас есть шаблон, такой как шаблон STL, такой тип шаблона класса всегда будет возвращать ссылку, а не указатель, чтобы упростить чтение или присвоение нового значения с помощью оператора []:

Std ::vector<int>v(10); // Initialize a vector with 10 elements
V[5] = 5; // Writing the value 5 into the 6 element of our vector, so if the returned type of operator [] was a pointer and not a reference we should write this *v[5]=5, by making a reference we overwrite the element by using the assignment "="
+6
06 янв. '17 в 14:01
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос