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

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

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

Цель ссылки не может быть заменена никаким способом, кроме UB.

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

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 &q; // error
   int &r = x;
   

2. Переменная-указатель имеет свой собственный идентификатор: отдельный видимый адрес памяти, который можно взять с помощью унарного оператора &, и определенный объем пространства, который можно измерить с помощью оператора sizeof. Использование этих операторов для ссылки возвращает значение, соответствующее тому, к чему привязана ссылка; адрес и размер ссылки не видны. Поскольку ссылка таким образом предполагает идентичность исходной переменной, удобно думать о ссылке как о другом имени той же переменной.

   int x = 0;
   int &r = x;
   int *p = &x;
   int *p2 = &r;
   
   assert(p == p2); // &x == &r
   assert(&p != &p2);
   

3. Вы можете иметь произвольно вложенные указатели на указатели, предлагающие дополнительные уровни косвенности. Ссылки предлагают только один уровень косвенности.

   int x = 0;
   int y = 0;
   int *p = &x;
   int *q = &y;
   int **pp = &p;
   
   **pp = 2;
   pp = &q; // *pp is now q
   **pp = 4;
   
   assert(y == 4);
   assert(x == 2);
   

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

   /* the code below is undefined; your compiler may optimise it
    * differently, emit warnings, or outright refuse to compile it */
   
   int &r = *static_cast<int *>(nullptr);
   
   // prints "null" under GCC 10
   std::cout
       << (&r != nullptr
           ? "not null" : "null")
       << std::endl;
   
   bool f(int &r) { return &r != nullptr; }
   
   // prints "not null" under GCC 10
   std::cout
       << (f(*static_cast<int *>(nullptr))
           ? "not null" : "null")
       << std::endl;
   

   Однако вы можете иметь ссылку на указатель со значением nullptr.

5. Указатели могут перебирать массив; вы можете использовать ++ для перехода к следующему элементу, на который указывает указатель, и + 4 для перехода к 5-му элементу. Это не имеет значения, какого размера объект, на который указывает указатель.

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

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

8. Ссылки на константы можно привязать к временным файлам. Указатели не могут (не без косвенного обращения):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вариант по умолчанию использует «привязку константной ссылки к временному» аспекту ссылок.

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

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

Например:

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 работать.

На самом деле ссылка не похожа на указатель.

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

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

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

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

int a = 0;
int& b = a;

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

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

int a;
increment(a);

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

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

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

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

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

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

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

Рассмотрим следующий оператор из C++ FAQ:

Even though a reference is often implemented using an address in the underlying assembly language, please do not think of a reference as a funny looking pointer to an object. A reference is the object. It is not a pointer to the object, nor a copy of the object. It is the object.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Есть одно фундаментальное различие между указателями и ссылками, о котором я не видел, чтобы кто-то упоминал: ссылки включают семантику передачи по ссылке в аргументах функции. Указатели, хотя сначала они не видны, их нет: они обеспечивают только семантику передачи по значению. Это очень хорошо описано в Эта статья.

С уважением, & Ржей

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

    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. 

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

int& j = i;

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

int* const j = &i;

Эта программа может помочь понять ответ на вопрос. Это простая программа со ссылкой «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://thewikihow.com/video_rlJrrGV0iOg

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

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

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

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
}

Для такой оптимизации нужно доказать, что во время вызова ничего не может изменить array [1]. Сделать это довольно просто. i никогда не меньше 2, поэтому array [i] никогда не может ссылаться на array [1]. MaybeModify () дается a0 в качестве ссылки (массив псевдонимов [0]). Поскольку не существует «ссылочной» арифметики, компилятор просто должен доказать, что возможноModify никогда не получает адрес x, и он доказал, что ничего не меняет array [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 никогда не изменяет array [1], потому что мы уже дали ему указатель; кошка вылезла из мешка. Теперь ему нужно сделать гораздо более сложное доказательство: статический анализ MaybeModify, чтобы доказать, что он никогда не записывает в & x + 1. Он также должен доказать, что он никогда не сохраняет указатель, который может ссылаться на array [0], что просто как сложно.

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

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

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

F createF(int argument);

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

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

Это основано на руководство. То, что написано, проясняет:

>>> 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.

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

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

Посетите следующую страницу для получения дополнительной информации о ссылке на указатель:

• C++: ссылка на указатель
• Указатель на указатель и ссылка на указатель

Как я уже сказал, указатель на ссылку невозможен. Попробуйте следующую программу:

#include <iostream>
using namespace std;

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

Разница в том, что неконстантная переменная-указатель (не путать с указателем на константу) может быть изменена в какой-то момент во время выполнения программы, требует использования семантики указателя (&, *) операторов, в то время как ссылки могут быть установлены при инициализации. только (поэтому вы можете установить их только в списке инициализаторов конструктора, но не как-то еще) и использовать обычную семантику доступа к значениям. В основном ссылки были введены для поддержки перегрузки операторов, как я читал в одной очень старой книге. Как кто-то заявил в этом потоке, указатель может быть установлен на 0 или любое другое значение, которое вы хотите. 0 (NULL, nullptr) означает, что указатель не инициализирован ничем. Разыменовать нулевой указатель является ошибкой. Но на самом деле указатель может содержать значение, которое не указывает на какое-то правильное место в памяти. Ссылки, в свою очередь, стараются не позволить пользователю инициализировать ссылку на то, на что нельзя ссылаться, потому что вы всегда предоставляете ей rvalue правильного типа. Хотя существует множество способов инициализировать ссылочную переменную в неправильном месте памяти, лучше не вдаваться в подробности. На машинном уровне и указатель, и ссылка работают единообразно - через указатели. Скажем, существенные ссылки содержат синтаксический сахар. Ссылки rvalue отличаются от этого - они, естественно, являются объектами стека / кучи.

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

Указатель может быть инициализирован 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 " = "

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

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

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

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

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

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

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

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

Я всегда выбираю правило это из C++ Core Guidelines:

Prefer T* over T& when "no argument" is a valid option

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

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, даже если функция никогда не ожидает nullptr. То есть эти люди утверждают, что сигнатуры функций, подобные fn3() выше, не должны быть разрешены. Рекомендации Google по стилю C++ являются примером этого.

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

// receives an alias of an int, an address of an int and an int value
public void my_function(int& a,int* b,int c){
    int d = 1; // declares an integer named d
    int &e = d; // declares that e is an alias of d
    // using either d or e will yield the same result as d and e name the same object
    int *f = e; // invalid, you are trying to place an object in an address
    // imagine writting your name in an address field 
    int *g = f; // writes an address to an address
    g = &d; // &d means get me the address of the object named d you could also
    // use &e as it is an alias of d and write it on g, which is an address so it's ok
}

Тарин ♦ сказала:

You can't take the address of a reference like you can with pointers.

На самом деле можно.

Цитирую из ответ на другой вопрос:

The C++ FAQ says it best:

Unlike a pointer, once a reference is bound to an object, it can not be "reseated" to another object. The reference itself isn't an object (it has no identity; taking the address of a reference gives you the address of the referent; remember: the reference is its referent).

Вы можете использовать разницу между ссылками и указателями, если вы следуете соглашению об аргументах, передаваемых функции. Ссылки на константы предназначены для данных, передаваемых в функцию, а указатели - для данных, передаваемых из функции. На других языках это можно явно обозначить такими ключевыми словами, как in и out. В C++ вы можете объявить (по соглашению) эквивалент. Например,

void DoSomething(const Foo& thisIsAnInput, Foo* thisIsAnOutput)
{
   if (thisIsAnOuput)
      *thisIsAnOutput = thisIsAnInput;
}

Использование ссылок в качестве входов и указателей в качестве выходов является частью Руководство по стилю Google.

Помимо всех ответов здесь,

вы можете реализовать перегрузку оператора, используя ссылки:

my_point operator+(const my_point& a, const my_point& b)
{
  return { a.x + b.x, a.y + b.y };
}

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

Некоторые важные важные сведения о ссылках и указателях

Указатели

• Переменные-указатели объявляются с использованием оператор объявления унарного суффикса *
• Объектам-указателям присваивается значение адреса, например, путем присвоения объекту массива, адреса объекта с помощью & унарный префиксный оператор или присвоения значению другого объекта-указателя.
• Указатель можно переназначать любое количество раз, указывая на разные объекты.
• Указатель - это переменная, которая содержит назначенный адрес. Он занимает место в памяти, равное размеру адреса для архитектуры целевой машины.
• Указателем можно манипулировать математически, например, с помощью операторов приращения или сложения. Следовательно, можно выполнять итерацию с помощью указателя и т. д.
• Чтобы получить или установить содержимое объекта, на который указывает указатель, необходимо использовать унарный префиксный оператор * для разыменование it.

Рекомендации

• Ссылки должны быть инициализированы при объявлении.
• Ссылки объявляются с использованием оператор объявления унарного суффикса &.
• При инициализации ссылки используется имя объекта, на который они будут ссылаться напрямую, без необходимости в унарный префиксный оператор &
• После инициализации ссылки нельзя указывать на что-либо еще с помощью присваивания или арифметических манипуляций.
• Нет необходимости разыменовать ссылку, чтобы получить или установить содержимое объекта, на который она ссылается.
• Операции присваивания для ссылки управляют содержимым объекта, на который она указывает (после инициализации), а не самой ссылкой (не изменяется там, где она указывает)
• Арифметические операции со ссылкой управляют содержимым объекта, на который она указывает, а не самой ссылкой (не меняет место, на которое она указывает)
• Практически во всех реализациях ссылка фактически сохраняется как адрес в памяти упомянутого объекта. Следовательно, он занимает место в памяти, равное размеру адреса для архитектуры целевой машины, точно так же, как объект-указатель.

Несмотря на то, что указатели и ссылки реализуются во многом одинаково «изнутри», компилятор обрабатывает их по-разному, что приводит ко всем различиям, описанным выше.

Статья

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

Подробная статья о массивах, указателях и ссылках

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

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

C имел только семантику передачи по значению. Получение адреса данных, на которые ссылалась переменная, и отправка их в функцию - это способ передать их по «ссылке». Ссылка сокращает это семантически, «ссылаясь» на само исходное расположение данных. Так:

int x = 1;
int *y = &x;
int &z = x;

Y - это указатель типа int, указывающий на место, где хранится x. X и Z относятся к одному и тому же месту хранения (стек или куча).

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

1) «Указатель может быть повторно назначен любое количество раз, в то время как ссылка не может быть повторно назначена после привязки». - указатель - это тип данных адреса, который указывает на данные. Ссылка - это другое название данных. Таким образом, вы может «переназначаете» ссылку. Вы просто не можете переназначить местоположение данных, к которому они относятся. Точно так же, как вы не можете изменить расположение данных, к которому относится «x», вы не можете сделать это с «z».

x = 2;
*y = 2;
z = 2;

Такой же. Это переназначение.

2) «Указатели могут никуда не указывать (NULL), тогда как ссылка всегда относится к объекту» - опять же с путаницей. Ссылка - это просто другое имя объекта. Нулевой указатель означает (семантически), что он ни на что не ссылается, тогда как ссылка была создана, говоря, что это было другое имя для 'x'. С

3) «Вы не можете взять адрес ссылки, как вы можете с помощью указателей» - Да, можете. Опять путаница. Если вы пытаетесь найти адрес указателя, который используется в качестве ссылки, это проблема - потому что ссылки не являются указателями на объект. Они объект. Таким образом, вы можете получить адрес объекта и адрес указателя. Потому что они оба получают адрес данных (одно - расположение объекта в памяти, другое - указатель на расположение объекта в памяти).

int *yz = &z; -- legal
int **yy = &y; -- legal

int *yx = &x; -- legal; notice how this looks like the z example.  x and z are equivalent.

4) «Нет« ссылочной арифметики »» - опять же с путаницей - поскольку в приведенном выше примере z является ссылкой на x, и поэтому оба являются целыми числами, арифметика «ссылка» означает, например, добавление 1 к значению, на которое указывает Икс.

x++;
z++;

*y++;  // what people assume is happening behind the scenes, but isn't. it would produce the same results in this example.
*(y++);  // this one adds to the pointer, and then dereferences it.  It makes sense that a pointer datatype (an address) can be incremented.  Just like an int can be incremented. 

Основное значение указателя (*) - «Значение по адресу», что означает, что какой бы адрес вы ни указали, он будет давать значение по этому адресу. Как только вы измените адрес, он даст новое значение, тогда как ссылочная переменная используется для ссылки на любую конкретную переменную и не может быть изменена для ссылки на любую другую переменную в будущем.

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

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

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

The C++ standard is very careful to avoid dictating how a compiler may implement references, but every C++ compiler implements references as pointers. That is, a declaration such as:

int &ri = i;

if it's not optimized away entirely, allocates the same amount of storage as a pointer, and places the address of i into that storage.

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

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

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

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

• Мой самый любимый C++ FAQ lite.
• Ссылки против указателей.
• Введение в ссылки.
• Ссылки и const.

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

int a = 20;
int &r = a;
r = 40;  /* now the value of a is changed to 40 */

int b =20;
int *ptr;
ptr = &b;  /*assigns address of b to ptr not the value */

Ссылка - это константный указатель. int * const a = &b такой же, как int& a = b. Вот почему не существует такой вещи, как ссылка на константу, потому что она уже является константой, тогда как ссылка на константу - это const int * const a. Когда вы компилируете с использованием -O0, компилятор помещает адрес b в стек в обеих ситуациях, и как член класса он также будет присутствовать в объекте в стеке / куче, как если бы вы объявили константный указатель. С -Ofast это можно оптимизировать бесплатно.

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

#include <iostream>

int main() {
  int a =1;
  int* b = &a;
  std::cout << b ;
}

int main() {
  int a =1;
  int& b = a;
  std::cout << &b ;
}

they both have the same assembly output
-Ofast:
main:
        sub     rsp, 24
        mov     edi, OFFSET FLAT:_ZSt4cout
        lea     rsi, [rsp+12]
        mov     DWORD PTR [rsp+12], 1
        call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<void const*>(void const*)
        xor     eax, eax
        add     rsp, 24
        ret

-O0:
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-12], 1
        lea     rax, [rbp-12]
        mov     QWORD PTR [rbp-8], rax
        mov     rax, QWORD PTR [rbp-8]
        mov     rsi, rax
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(void const*)
        mov     eax, 0
        leave
        ret

Как члены объекта они идентичны от -O0 до -Ofast.

#include <iostream>
int b=1;
struct A {int* i=&b; int& j=b;};
A a;
int main() {
  std::cout << &a.j << &a.i;
}

The address of b is stored twice in the object. 

a:
        .quad   b
        .quad   b

        mov     rax, QWORD PTR a[rip+8] //&a.j
        mov     esi, OFFSET FLAT:a //&a.i