C указатели и ссылки: Ссылки, указатели, константность — Основы С++

Указатели и ссылки в языке C++. А также Java и C♯

Указатели и ссылки в языке C++

А также Java и C♯

В языке C++ практически с самого начала его существования есть две реализации ссылочного типа: это указатели (pointers) и ссылки (references). Указатели достались от языка C. Ссылки не заменили указатели во всём, а умные/интеллектуальные указатели (smart pointers) не всегда стоит использовать вместо «сырых» (raw pointers). В C++11 появился новый тип — rvalue-ссылки — который преследует совсем иные цели.

Ссылки появились в C++ ещё в тот момент, когда он миновал этап C with Classes, для перегрузки операторов:

«Дуг Макилрой вспоминает, что однажды я объяснял ему некоторые проблемы, касавшиеся схемы перегрузки операторов. Он употребил слово „ссылка“, после чего я, пробормотав „спасибо“, выбежал из его кабинета, чтобы на следующий день появиться с практически готовым решением, которое и вошло в язык. Просто Дуг тогда напомнил мне об Algol68».

В первом приближении разница между указателями и ссылками такова (для сравнения — ссылки в языках Java и C♯).

Указатели в C

Указатели в C++

Ссылки в C++

Ссылки в языках Java и C♯

Обязательно инициализировать

–

–

+

–

Можно переназначить

+ (если не const)

+ (если не const)

–

+

Значение по умолчанию

Мусорное

Мусорное

–

null

Невалидное значение

NULL

NULL/nullptr (C++11)

–

null

Коллекции

+

+

–

+

Арифметика

+

+

–

–

Косвенность

+

+

–

–

Из таблицы видно, что ссылки в Java и C♯, несмотря на название, больше похожи на указатели в C и C++ (но без присущей им арифметики и косвенности — как указатели на указатели).

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

Может изменяться

Не может изменяться

Может изменять то, на что указывает

T* ptr

T* const ptr,
T& ref

Не может изменять то, на что указывает

const T * ptr ≡ T const * ptr

const T * const ptr,
const T& ref ≡ T const& ref

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

Бьерн Страуструп, создатель языка C++:

«В языке Java есть указатели. На самом деле там почти всё неявно оказывается указателем. Просто там их называют ссылками (references). В том, что указатели неявные, есть свои преимущества и недостатки. Попутно отмечу, что наличие подлинно локальных объектов (как в C++) также имеет как преимущества, так и недостатки. […] А вездесущие неявно используемые в языке Java указатели (они же ссылки) закрывают путь ко всем этим возможностям […]

Благодаря повсеместному и неявному использованию ссылок в Java, возможно, удалось упростить модель программирования и сборку мусора, но расход памяти при этом резко вырос — и соответственно выросли стоимость доступа к памяти (осуществляемого более косвенным образом) и расходы на выделение памяти.

Чего в языке Java, к счастью, нет, так это допускаемого языками C и C++ неправильного применения арифметики указателей. Но и эта проблема решается, если корректно писать код на языке C++, используя такие высокоуровневые абстракции, как потоки ввода/вывода, контейнеры и алгоритмы, а не занимаясь вознёй с указателями. […]

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

„Отрицательная“ сторона наличия указателей (и массивов в стиле C) — это, конечно, возможность злоупотреблений: переполнение буфера, указатели на удалённую память, неинициализированные указатели и т. п. Но если корректно писать код на языке C++, всё не столь страшно. […] Те, кто привык работать на C или придерживается старого стиля в языке C++, с трудом верят тому, что управление ресурсами на основе областей видимости представляет собой исключительно мощный инструмент».

14 июня 2022

Светлая тема / тёмная тема

Разница между указателем и ссылкой — Только Факты!

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

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

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

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

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

Что такое указатель?

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

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

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

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

Data_type * var-name;

Здесь «Data_type» — это базовый тип указателя, а «var-name» — переменная указателя. Звездочка (*) здесь используется для объявления указателя, который обозначает переменную «var-name» как переменную-указатель.

int *p; // целочисленный указатель

float *x; // float-указатель

Здесь переменная «p» указывает на целочисленный тип данных, который объявлен как «int», что указывает на тип данных переменной. Аналогично, во втором примере «float» относится к типу данных переменной «x», которая на самом деле обозначена как указатель на переменную с плавающей точкой.

Что такое ссылка?

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

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

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

int i;

int &ri = i;

Здесь «ri» — это целочисленная ссылка, инициализированная на «i». Объявляется «ri» как объект типа «ссылка на int». Ссылку можно легко спутать с указателем, который является независимой переменной, адресные значения которой не могут быть переназначены после создания.

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

Основы работы с указателями и ссылками

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

Объявление указателя и ссылки

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

Переназначение указателя и ссылки

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

Адрес памяти для указателя и ссылки

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

Значение NULL для указателя и ссылки

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

Резюме: указатель против ссылки

Указатели всегда были одной из любимых тем для обсуждения программистов на языке Си/Си++, пока не появились ссылки. Ссылки в некоторой степени похожи на указатели, но имеют свою долю плюсов и минусов. Хотя и те, и другие могут использоваться для изменения локальных переменных одной функции внутри другой функции, у них есть свои различия. Оба они являются мощными функциями в C и C++, позволяющими напрямую манипулировать памятью, но с некоторыми исключениями. Указатель хранит в памяти адрес переменной, тогда как ссылка — это просто псевдоним для другой переменной.

Указатели и ссылки в C++

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

C и C++ поддерживают указатели, что отличается от большинства других языков программирования, таких как Java, Python, Ruby, Perl и PHP, поскольку они поддерживают только ссылки. Но что интересно, C++, наряду с указателями, также поддерживает ссылки.

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

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

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

 интервал i = 3;
// Указатель на переменную i или "хранит адрес i"
интервал *ptr = &i;
// Ссылка (или псевдоним) для i.
интервал & ссылка = я; 

Отличия :  

1. Инициализация: Указатель можно инициализировать следующим образом: 

 int a = 10;
интервал *р = &а;
// ИЛИ
интервал *р;
р = &а; 

Мы можем объявить и инициализировать указатель на одном шаге или в нескольких строках.

2. Пока в ссылках,

 инт а = 10;
интервал & р = а; // Верно
// но
интервал &р;
р = а; // Это неверно, так как мы должны объявлять и инициализировать ссылки за один шаг 

ПРИМЕЧАНИЕ: Эта разница может варьироваться от компилятора к компилятору. Вышеуказанная разница относится к Turbo IDE.

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

 инт а = 5;
интервал б = 6;
интервал *р;
р = &а;
р = &б; 

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

 инт а = 5;
интервал б = 6;
интервал & р = а;
интервал & р = б; // Это вызовет ошибку "множественное объявление не разрешено"
// Тем не менее, это правильное утверждение,
интервал &q = р; 

5. Адрес памяти: Указатель имеет собственный адрес памяти и размер в стеке, тогда как ссылка использует тот же адрес памяти, что и исходная переменная, но также занимает некоторое место в стеке.

 интервал &p = а;
cout << &p << endl << &a; 

6. Значение NULL: Указатель может быть напрямую назначен NULL, тогда как ссылка не может.

7. Косвенность: У вас может быть указатель на указатель (известный как двойной указатель), предлагающий дополнительные уровни косвенности, тогда как ссылки предлагают только один уровень косвенности. Например,

 В указателях,
инт а = 10;
интервал *р;
интервал **к; // Это действительно.
р = &а;
д = &р;
// Тогда как в ссылках
интервал & р = а;
интервал &&q = р; // Это ссылка на ссылку, так что это ошибка 

8. Арифметические операции: С указателями могут выполняться различные арифметические операции, тогда как нет такой вещи, как арифметика ссылок (однако, вы можете выполнять арифметические операции с указателями по адресу объекта, на который указывает ссылка, как в &obj + 5).

Табличная форма разницы между ссылками и указателями в C++

	назначение	Переменная не может быть переназначена в Reference.	Переменная может быть переназначена в Указатели.
Адрес памяти	Имеет тот же адрес, что и исходная переменная.	Указатели имеют собственный адрес в памяти.
Работа	Имеется в виду другая переменная.	Сохраняет адрес переменной.
Нулевое значение	Не имеет нулевого значения.	Может иметь нулевое значение.
Аргументы	На эту переменную ссылается метод, передаваемый по значению.	Указатель работает методом передачи по ссылке.

Когда использовать Что

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

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

Цитируется по C++ FAQ Lite: Используйте ссылки, когда можете, и указатели, когда необходимо. Ссылки обычно предпочтительнее указателей, когда вам не нужно «переустанавливать». Обычно это означает, что ссылки наиболее полезны в общедоступном интерфейсе класса. Ссылки обычно появляются на поверхности объекта, а указатели — внутри.

Исключением из вышеизложенного является случай, когда для параметра функции или возвращаемого значения требуется ссылка «дозорная» — ссылка, которая не относится к объекту. Обычно это лучше всего сделать, вернув/взяв указатель и придав значению nullptr особое значение (ссылки всегда должны быть псевдонимами объектов, а не разыменованным нулевым указателем).

Статья по теме: 
Когда мы передаем аргументы как ссылку или указатели?

Эта статья предоставлена ​​ Ришав Радж . Если вам нравится GeeksforGeeks и вы хотите внести свой вклад, вы также можете написать статью с помощью write.geeksforgeeks.org или отправить ее по адресу [email protected]. Посмотрите, как ваша статья появится на главной странице GeeksforGeeks, и помогите другим гикам.

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

Понимание указателей и ссылок в C++ — Блог Coding Ninjas

Содержание

Введение

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

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

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

 Как инициализировать указатель: 
  Случай 1:  
 int a = 100; // Рассмотрим целочисленную переменную как хранимое значение 100 
 int *b = &a; // Здесь переменная b является указателем, хранящим адрес памяти 
  Случай 2:  
 int *b; // Инициализация переменной указателя b 
 b = &a; // Присвоение адреса переменной a указателю b 
 Примечание: (амперсанд означает, что к адресу осуществляется доступ) 

 Как переназначить существующий указатель: 
 int a = 25; // Целочисленной переменной присвоено значение 25 
 int b = 30; // Целочисленной переменной b присвоено значение 30 
 int *x; // Объявление указателя x 
 x = &a; // Присвоение значения переменной a указателю x через доступ к адресу памяти 
 х = &b; // Присвоение значения переменной b указателю x через доступ к адресу памяти 

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

Пример:

 #include  
 using namespace std; 
 int main(){ 
 // Объявление указателя 
 int  p, var=101; //Присваивание p = &var; cout<<"Адрес переменной: "<<&var< p; 
 возврат 0; 
 } 

 Как инициализировать ссылку: 
 int a = 30; // Целочисленная переменная a присваивает значение 30 
 int &x = a; // Здесь мы предоставляем ссылку на x 

 #include  

 using namespace std; 
 int main () { 
 // объявление простых переменных 
 int i; 
 двойной д; 

 // объявление ссылочных переменных 
 int& r = i; 
 двойной& с = д; 
 я = 5; 
 cout << "Значение i : " << i << endl; 
 cout << "Значение ссылки i: " << r << endl; 
 д = 11,7; 
 cout << "Значение d : " << d << endl; 
 cout << "Значение ссылки d: " << s << endl; 
 возврат 0; 
 } 

 void f1(const комплекс* x, const комплекс* y) // без ссылок 
 { 
 комплекс z =  x+  y; // некрасиво 
 // … 
 } 
 void f2(constcomplex&x, constcomplex&y) // со ссылками 
 { 
complexz = x+y; // лучше 
 // … 
 } 

 Ref r :- новый My_type; 
 г := 7; // присваиваем объекту 
 r :- new My_type; // присваиваем ссылку 
 В качестве альтернативы вы можете полагаться на проверку типов (перегрузку).  

  Пример:  
 Ref r = новый My_type; 
 г = 7; // присваиваем объекту 
 r = new My_type; // присвоить ссылку 

 include  

 using namespace std; 
 int main() { 
 int число1 = 88, число2 = 22; 

 // Создать указатель, указывающий на number1 
 int * pNumber1 = &number1; // Явная ссылка 
 *pNumber1 = 99; // Явное разыменование 
 cout << *pNumber1 << endl; // 99 
 cout << &number1 << endl; // 0x22ff18 

 cout << pNumber1 << endl; // 0x22ff18 (содержимое переменной-указателя - 
 то же, что и выше) 
 cout << &pNumber1 << endl; // 0x22ff10 (адрес переменной-указателя) 
 pNumber1 = &number2; // Указатель можно переназначить для хранения другого адреса 
 

 
 int & refNumber1 = number1; // Неявная ссылка (НЕ &number1) 
 refNumber1 = 11; // Неявное разыменование (НЕ  refNumber1) cout << refNumber1 << endl; // 11 cout << &number1 << endl; // 0x22ff18 cout << &refNumber1 << endl; // 0x22ff18 //refNumber1 = &number2; // Ошибка! Ссылка не может быть переназначена // ошибка: неверное преобразование из 'int ' в 'int' 
 refNumber1 = number2; // refNumber1 по-прежнему является псевдонимом number1.  
 // Присвоить значение number2 (22) refNumber1 (и 
 number1). 
 номер2++; 
 cout << refNumber1 << endl; // 22 
 cout << число1 << endl; // 22 
 cout << число2 << endl; // 23 
 }