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

© MMXI—MMXXIII. RSS. Поддержать сайт

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

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

И указатели, и ссылки являются наиболее мощными функциями в 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, тогда как ссылка не может.

Ограничения, связанные со ссылками (без 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;
}

Примечание: 

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

Теперь, каково применение ссылок?

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

Ключевые факты, которые следует помнить об указателях и ссылках:
  • У указателя есть собственный адрес памяти и размер в стеке, но при рассмотрении сценария со ссылками они используют один и тот же адрес памяти, но занимают размер в стеке.
  • Еще одна вещь, о которой следует помнить, это то, что указателю может быть присвоено значение null, но это не может быть справочным случаем.
  • Также в случае указателя у вас может быть несколько уровней косвенности, например указатель, указывающий на b и b на c и так далее. Но в случае ссылок существует только один уровень косвенности.

Почему в С++ есть и указатели, и ссылки?

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

Пример:

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

В более общем случае, если вы хотите иметь как функциональность указателей, так и функциональность ссылок, вам нужны либо два разных типа (как в C++), либо два разных набора операций над одним типом. Например, с одним типом вам нужна как операция для присваивания объекту, на который делается ссылка, так и операция для присваивания ссылке/указателю. Это можно сделать с помощью отдельных операторов (как в Simula).

Пример:

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

Когда следует использовать ссылки и указатели?

Используйте ссылки, когда можете, и указатели, когда необходимо.

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

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

Ссылка против указателей:

Указатели и ссылки эквивалентны, за исключением следующего:

  • Ссылка — это константа имени для адреса. Вам нужно инициализировать ссылку во время объявления. интервал и ссылка; // Ошибка: iRef объявлен как ссылка, но не инициализирован.
  • После установления ссылки на переменную нельзя изменить ссылку на другую переменную.
  • Чтобы получить значение, на которое указывает указатель, необходимо использовать оператор разыменования  (например, если pNumber является указателем типа int, pNumber возвращает значение, на которое указывает pNumber. Это называется разыменованием или косвенным обращением). Чтобы присвоить адрес переменной указателю, необходимо использовать оператор адреса & (например, pNumber = &number).
  • С другой стороны, ссылки и разыменования выполняются для ссылок неявно. Например, если refNumber является ссылкой (псевдонимом) на другую переменную int, refNumber возвращает значение переменной. Нельзя использовать явный оператор разыменования *. Кроме того, чтобы присвоить адрес переменной ссылочной переменной, оператор адреса & не требуется.

Пример:
/* Ссылки и указатели (TestReferenceVsPointer.cpp) */

 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; // Указатель можно переназначить для хранения другого адреса

// Создать ссылку (псевдоним) на номер1

 
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
}

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

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

Заключение

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

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *