c ++ указатели и ссылки [дубликат]

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

int& j = i;

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

int* const j = &i;

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

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

Например:

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

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

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

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 & lt; & lt; str_ref; ПОСЛЕ вызова delete & amp; str_ref? Ну, очевидно, что он компилируется нормально, но вызывает ошибку сегментации во время выполнения, потому что он больше не указывает на допустимую переменную, мы по существу имеем сломанную ссылку, которая все еще существует (пока она не выпадает из области), но бесполезна.

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

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

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

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

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

Ссылки менее эффективны, чем указатели

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

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

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

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

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

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

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

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

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

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

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

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

Я использую ссылки, если мне не требуется ни одно из них:

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