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

Вопрос

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

Object *myObject = new Object;

Object myObject;

Аналогично с методами. Почему вместо этого:

MyObject.testFunc();

мы должны писать вот это:

MyObject->testFunc();

Я так понимаю, что это дает выигрыш в скорости, т.к. мы обращаемся напрямую к памяти. Верно? P.S. Я перешел с Java.

Ответ

Заметим, кстати, что в Java указатели не используются в явном виде, т.е. программист не может в коде обратиться к объекту через указатель на него. Однако на деле в Java все типы, кроме базовых, являются ссылочными: обращение к ним происходит по ссылке, хотя явно передать параметр по ссылке нельзя. И еще, на заметку, new в C++ и в Java или C# - абсолютно разные вещи.

Для того, чтобы дать небольшое представление, что же такое указатели в C++, приведем два аналогичных фрагмента кода:

Object object1 = new Object(); // Новый объект Object object2 = new Object(); // Еще один новый объект object1 = object2;// Обе переменные ссылаются на объект, на который раньше ссылалась object2 // При изменении объекта, на который ссылается object1, изменится и // object2, потому что это один и тот же объект

Ближайший эквивалент на C++:

Object * object1 = new Object(); // Память выделена под новый объект // На эту память ссылается object1 Object * object2 = new Object(); // Аналогично со вторым объектом delete object1; // В C++ нет системы сборки мусора, поэтому если этого не cделать, // к этой памяти программа уже не сможет получить доступ, // как минимум, до перезапуска программы // Это называется утечкой памяти object1 = object2; // Как и в Java, object1 указывает туда же, куда и object2

Однако вот это – совершенно другая вещь (C++):

Object object1; // Новый объект Object object2; // Еще один object1 = object2;// Полное копирование объекта object2 в object1, // а не переопределение указателя – очень дорогая операция

Но получим ли мы выигрыш в скорости, обращаясь напрямую к памяти?

Строго говоря, этот вопрос объединяет в себе два различных вопроса. Первый: когда стоит использовать динамическое распределение памяти? Второй: когда стоит использовать указатели? Естественно, здесь мы не обойдемся без общих слов о том, что всегда необходимо выбирать наиболее подходящий инструмент для работы. Почти всегда существует реализация лучше, чем с использованием ручного динамического распределения (dynamic allocation) и / или сырых указателей.

Динамическое распределение

В формулировке вопроса представлены два способа создания объекта. И основное различие заключается в сроке их жизни (storage duration) в памяти программы. Используя Object myObject; , вы полагаетесь на автоматическое определение срока жизни, и объект будет уничтожен сразу после выхода из его области видимости. А вот Object *myObject = new Object; сохраняет жизнь объекту до того момента, пока вы вручную не удалите его из памяти командой delete . Используйте последний вариант только тогда, когда это действительно необходимо. А потому всегда делайте выбор в пользу автоматического определения срока хранения объекта, если это возможно .

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

• Вам необходимо, чтобы объект существовал и после выхода из области его видимости - именно этот объект, именно в этой области памяти, а не его копия. Если для вас это не принципиально (в большинстве случаев это так), положитесь на автоматическое определение срока жизни. Однако вот пример ситуации, когда вам может понадобиться обратить к объекту вне его области видимости, однако это можно сделать, не сохраняя его в явном виде: записав объект в вектор, вы можете “разорвать связь” с самим объектом - на самом деле он (а не его копия) будет доступен при вызове из вектора.
• Вам необходимо использовать много памяти , которая может переполнить стек. Здорово, если с такой проблемой не приходится сталкиваться (а с ней сталкиваются очень редко), потому что это “вне компетенции” C++, но к сожалению, иногда приходится решать и эту задачу.
• Вы, например, точно не знаете размер массива, который придется использовать . Как известно, в C++ массивы при определении имеют фиксированный размер. Это может вызвать проблемы, например, при считывании пользовательского ввода. Указатель же определяет только тот участок в памяти, куда будет записано начало массива, грубо говоря, не ограничивая его размер.

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

Указатели

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

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

• Ссылочная семантика . Иногда может быть необходимо обратиться к объекту (вне зависимости от того, как под него распределена память), поскольку вы хотите обратиться в функции именно в этому объекту, а не его копии - т.е. когда вам требуется реализовать передачу по ссылке. Однако в большинстве случаев, здесь достаточно использовать именно ссылку, а не указатель, потому что именно для этого ссылки и созданы. Заметьте, что это несколько разные вещи с тем, что описано в пункте 1 выше. Но если вы можете обратиться к копии объекта, то и ссылку использовать нет необходимости (но заметьте, копирование объекта - дорогая операция).
• Полиморфизм . Вызов функций в рамках полиморфизма (динамический класс объекта) возможен с помощью ссылки или указателя. И снова, использование ссылок более предпочтительно.
• Необязательный объект . В этом случае можно использовать nullptr , чтобы указать, что объект опущен. Если это аргумент функции, то лучше сделайте реализацию с аргументами по умолчанию или перегрузкой. С другой стороны, можно использовать тип, который инкапсулирует такое поведение, например, boost::optional (измененный в C++14 std::optional).
• Повышение скорости компиляции . Вам может быть необходимо разделить единицы компиляции (compilation units) . Одним из эффективных применений указателей является предварительная декларация (т.к. для использования объекта вам необходимо предварительно его определить). Это позволит вам разнести единицы компиляции, что может положительно сказаться на ускорении времени компиляции, внушительно уменьшив время, затрачиваемое на этот процесс.
• Взаимодействие с библиотекой C или C-подобной . Здесь вам придется использовать сырые указатели, освобождение памяти из-под которых вы производите в самый последний момент. Получить сырой указатель можно из умного указателя, например, операцией get . Если библиотека использует память, которая впоследствии должна быть освобождена вручную, вы можете оформить деструктор в умном указателе.

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

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

int *countPtr, count;

объявляется переменная countPtrтипаint* (указатель на целочисленное значение). Символ * в объявлении распространяется только наcountPtr. Этот символ означает, что объявляемая переменная является указателем. Можно объявлять указатели, ссылающиеся на объекты любого типа.

Указатели должны быть инициализированы либо при объявлении, либо при помощи оператора присваивания. Указатель может быть инициализирован нулем, макросом NULLили значением адреса. Указатель со значениемNULLне указывает ни на что. Инициализация указателя значением 0 эквивалента инициализации указателя константойNULL, однако использованиеNULLпредпочтительнее. Когда присваивается значение 0, то происходит его преобразование к указателю соответствующего типа. Значение 0 является единственным целым числом, которой может быть присвоено переменной-указателю непосредственно.

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

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

Определения значения. Операция (*) выдает значение, хранящееся в указанной ячейке.

Получение адреса указателя. Подобно любым переменным переменная типа указатель имеет адрес и значение. Операция & сообщает, где находится сам указатель.

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

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

К указателям можно применить арифметические операции, такие как: ++, --, +, +=, -, -= и можно вычислить разность двух указателей.

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

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

Размер объекта в байтах зависит от типа объекта. Например, оператор

даст результат 3008 (3000+2*4), если для целого числа отводится в памяти 4 байта. Теперь vPtr будет ссылаться на элемент v.

Если бы vPtr был увеличен до значения 3016, которое соответствует адресу элемента массива v, то оператор

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

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

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

x = v2Ptr - vPtr;

переменной х будет присвоено число элементов массива, расположенных начиная с адреса vPtrи доv2Ptr; в данном случае это будет значение 2.

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

Передача параметра по ссылке. В Си для организации вызова по ссылке используются указатели и операция косвенной адресации. Если вызывается функция, аргументы которой должны изменяться, то в этом случае ей передаются адреса аргументов. Обычно для этой цели применяется операция взятия адреса (&) к переменной, значение которой будет изменяться. Когда адрес переменной передан функции, то для изменения ее значения может быть использована операция косвенной адресации (*). В следующей программе приведено использование передачи параметра по ссылке.

#include

{ int x=5, y=10;

printf(“x=%d y=%d\n”, x, y);

change(&x,&y); /* передача адресов функции */

printf(“x=%d y=%d\n”, x, y); }

change (int *u, int *v)

temp=*u; /*tempприсваивается значение, на которое указываетu*/

Результат программы:

Данная функция изменяет значения переменных xиy. Путем передачи функции адресов переменных х и у мы предоставили ей возможность доступа к ним. Используя указатели и операцию (*), функция смогла извлечь величины, помещенные в соответствующие ячейки памяти, и менять их местами.

Основная ли тература: 1осн,2осн

Дополнительная литератур а: 9доп

Контрольные вопросы:

1. Назовите операции для работы с указателями?

2. На какое число увеличивается значение указателя при прибавлении из указателя целого числа?

3. Приведите пример инициализации переменной-указателя?

4. Приведите пример объявления переменной-указателя?

5. Какая операция используется для организации вызова по ссылке?

Последнее обновление: 27.05.2017

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

Для определения указателя надо указать тип объекта, на который указывает указатель, и символ звездочки *. Например, определим указатель на объект типа int:

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

Int x = 10; // определяем переменную int *p; // определяем указатель p = &x; // указатель получает адрес переменной

Указатель хранит адрес объекта в памяти компьютера. И для получения адреса к переменной применяется операция & . Эта операция применяется только к таким объектам, которые хранятся в памяти компьютера, то есть к переменным и элементам массива.

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

Какой именно адрес имеет переменная x? Для вывода значения указателя можно использовать специальный спецификатор %p :

#include int main(void) { int x = 10; int *p; p = &x; printf("%p \n", p); // 0060FEA8 return 0; }

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

То есть в памяти компьютера есть адрес 0x0060FEA8, по которому располагается переменная x. Так как переменная x представляет тип int , то на большинстве архитектур она будет занимать следующие 4 байта (на конкретных архитектурах размер памяти для типа int может отличаться). Таким образом, переменная типа int последовательно займет ячейки памяти с адресами 0x0060FEA8, 0x0060FEA9, 0x0060FEAA, 0x0060FEAB.

И указатель p будет ссылаться на адрес, по которому располагается переменная x, то есть на адрес 0x0060FEA8.

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

#include int main(void) { int x = 10; int *p; p = &x; printf("Address = %p \n", p); printf("x = %d \n", *p); return 0; }

Консольный вывод:

Address = 0060FEA8 x = 10

Используя полученное значение в результате операции разыменования мы можем присвоить его другой переменной:

Int x = 10; int *p = &x; int y = *p; printf("x = %d \n", y); // 10

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

Int x = 10; int *p = &x; *p = 45; printf("x = %d \n", x); // 45

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

Создадим еще несколько указателей:

#include int main(void) { char c = "N"; int d = 10; short s = 2; char *pc = &c; // получаем адрес переменной с типа char int *pd = &d; // получаем адрес переменной d типа int short *ps = &s; // получаем адрес переменной s типа short printf("Variable c: address=%p \t value=%c \n", pc, *pc); printf("Variable d: address=%p \t value=%d \n", pd, *pd); printf("Variable s: address=%p \t value=%hd \n", ps, *ps); return 0; }

В моем случае я получу следующий консольный вывод:

Variable c: address=0060FEA3 value=N Variable d: address=0060FE9C value=10 Variable s: address=0060FE9A value=2

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

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

/* Ребят, в статье было найдено много ошибок. Спасибо тем людям, которые внесли свои замечания. В связи с этим - после прочтения статьи обязательно перечитайте комментарии */

1. Общие сведения

Итак, что же такое указатель? Указатель - это та же переменная, только инициализируется она не значением одного из множества типов данных в C++, а адресом, адресом некоторой переменной, которая была объявлена в коде ранее. Разберем на примере:

Void main(){ int i_val = 7; }
# Здесь ниже, конечно, я ребятки вам соврал. Переменная i_val - статическая, она явно будет размещена в стеке. В куче место выделяется под динамические объекты. Это важные вещи! Но в данном контексте, я, сделав сам себе замечание, позволю оставить себе все как есть, так что сильно не ругайтесь.

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

Void main(){ // 1 int i_val = 7; int* i_ptr = &i_val; // 2 void* v_ptr = (int *)&i_val }
Используя унарную операцию взятия адреса & , мы извлекаем адрес переменной i_val и присваиваем ее указателю. Здесь стоит обратить внимание на следующие вещи:

1. Тип, используемый при объявлении указателя в точности должен соответствовать типу переменной, адрес которой мы присваиваем указателю.
2. В качестве типа, который используется при объявлении указателя, можно выбрать тип void . Но в этом случае при инициализации указателя придется приводить его к типу переменной, на которую он указывает.
3. Не следует путать оператор взятия адреса со ссылкой на некоторое значение, которое так же визуально отображается символом & .

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

#include using namespace std; void main(){ int i_val = 7; int* i_ptr = &i_val; // выведем на экран значение переменной i_val cout << i_val << endl; // C1 cout << *i_ptr << endl; // C2 }

1. Здесь все ясно - используем саму переменную.
2. Во втором случае - мы обращаемся к значению переменной i_val через указатель. Но, как вы заметили, мы не просто используем имя указателя - здесь используется операция разыменования: она позволяет перейти от адреса к значению.

В предыдущем примере был организован только вывод значения переменной на экран. Можем ли мы непосредственно через указатель оперировать с значением переменной, на которую он указывает? Да, конечно, для этого они и реализованы (однако, не только для этого - но об этом чуть позже). Все, что нужно - сделать разыменование указателя:

(*i_ptr)++; // результат эквивалентен операции инкремента самой переменной: i_val++ // т.е. в данном случае в i_val сейчас хранится значение не 7, а 8.

2. Массивы

Сразу перейдем к примеру - рассмотрим статичный одномерный массив определенной длинны и инициализируем его элементы:

Void main(){ const int size = 7; // объявление int i_array; // инициализация элементов массива for (int i = 0; i != size; i++){ i_array[i] = i; } }
А теперь будем обращаться к элементам массива, используя указатели:

Int* arr_ptr = i_array; for (int i = 0; i != size; i++){ cout << *(arr_ptr + i) << endl; }
Что здесь происходит: мы инициализируем указатель arr_ptr адресом начала массива i_array . Затем, в цикле мы выводим элементы, обращаясь к каждому с помощью начального адреса и смещения. То есть:

*(arr_ptr + 0) это тот же самый нулевой элемент, смещение нулевое (i = 0),
*(arr_ptr + 1) - первый (i = 1), и так далее.

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

Int* arr_ptr_null = &i_array; for (int i = 0; i != size; i++){ cout << *(arr_ptr_null + i) << endl; } Пройдем по элементам с конца массива:
int* arr_ptr_end = &i_array; for (int i = 0; i != size; i++){ cout << *(arr_ptr_end - i) << endl; } Замечания:

1. Запись array[i] эквивалентна записи *(array + i ). Никто не запрещает использовать их комбинированно: (array + i ) - в этом случае смещение идет на i , и еще на единичку. Однако, в данном случае перед выражением (array + i ) ставить * не нужно. Наличие скобок это «компенсирует.
2. Следите за вашими „перемещениями“ по элементам массива - особенно если вам захочется использовать порнографический такой метод записи, как (array + i)[j].

3. Динамическое выделение памяти

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

Int size = -1; // здесь происходят какие - то // действия, которые изменяют // значение переменной size int* dyn_arr = new int;
Что здесь происходит: мы объявляем указатель и инициализируем его началом массива, под который выделяется память оператором new на size элементов. Следует заметить, что в этом случае мы можем использовать те же приемы в работе с указателями, что и с статическим массивом. Что следует из этого извлечь - если вам нужна какая - то структура (как массив, например), но ее размер вам заранее неизвестен, то просто сделайте объявление этой структуры, а проинициализируете ее уж позже. Более полный пример приведу чуть позже, а пока что - рассмотрим двойные указатели.

Что такое указатель на указатель? Это та же переменная, которая хранит адрес другого указателя „более низкого порядка“. Зачем он нужен? Для инициализации двумерного динамического массива, например:

Const int size = 7; // двумерный массив размером 7x7 int** i_arr = new int*; for(int i = 0; i != size; i++){ i_arr[i] = new int; }
А тройной указатель? Трехмерный динамический массив. Неинтересно, скажите вы, так можно продолжать до бесконечности. Ну хорошо. Тогда давайте представим себе ситуацию, когда нам нужно разместить динамические объекты какого-нибудь класса MyClass в двумерном динамическом массиве. Как это выглядит (пример иллюстрирует исключительно использование указателей, приведенный в примере класс никакой смысловой нагрузки не несет):

Class MyClass{ public: int a; public: MyClass(int v){ this->a = v; }; ~MyClass(){}; }; void main(){ MyClass*** v = new MyClass**; for (int i = 0; i != 7; i++){ v[i] = new MyClass*; for (int j = 0; j != 3; j++){ v[i][j] = new MyClass(i*j); } } } Здесь два указателя нужны для формирования матрицы, в которой будут располагаться объекты, третий - собственно для размещения там динамических объектов (не MyClass a , а MyClass* a ). Это не единственный пример использования указателей такого рода, чуть ниже будут рассмотрены еще примеры.

4. Указатель как аргумент функции

Для начала создадим два динамических массива размером 4x4 и проинициализируем их элементы некоторыми значениями:

Void f1(int**, int); void main(){ const int size = 4; // объявление и выделение памяти // под другие указатели int** a = new int*; int** b = new int*; // выделение памяти под числовые значения for (int i = 0; i != size; i++){ a[i] = new int; b[i] = new int; // собственно инициализация for (int j = 0; j != size; j++){ a[i][j] = i * j + 1; b[i][j] = i * j - 1; } } } void f1(int** a, int c){ for (int i = 0; i != c; i++){ for (int j = 0; j != c; j++){ cout.width(3); cout << a[i][j]; } cout << endl; } cout << endl; }
Функция f1 выводит значения массивов на экран: первый ее аргумент указатель на двумерный массив, второй - его размерность (указывается одно значение, потому как мы условились для простоты работать с массивами, где количество строк совпадает с количеством столбцов).

Задача : заменить значения элементов массива a соответствующими элементами из массива b , учитывая, что это должно произойти в некоторой функции, которая так или иначе занимается обработкой массивов. Цель: разобраться в способе передачи указателей для их дальнейшей модификации.

1. Вариант первый. Передаем собственно указатели a и b в качестве параметров функции:

   Void f2(int** a, int** b, int c){ for (int i = 0; i != c; i++){ for (int j = 0; j != c; j++){ a[i][j] = b[i][j]; } } } После вызова данной функции в теле main - f2(a, b, 4) содержимое массивов a и b станет одинаковым.

2. Вариант второй. Заменить значение указателя: просто присвоить значение указателя b указателю a.

   Void main(){ const int size = 4; // объявление и выделение памяти // под другие указатели int** a = new int*; int** b = new int*; // выделение памяти под числовые значения for (int i = 0; i != size; i++){ a[i] = new int; b[i] = new int; // собственно инициализация for (int j = 0; j != size; j++){ a[i][j] = i * j + 1; b[i][j] = i * j - 1; } } // Здесь это сработает a = b; }
   Однако, нам интересен случай, когда массивы обрабатываются в некоторой функции. Что первое приходит на ум? Передать указатели в качестве параметров нашей функции и там сделать то же самое: присвоить указателю a значение указателя b . То есть реализовать следующую функцию:

   Void f3(int** a, int** b){ a = b; } Сработает ли она? Если мы внутри функции f3 вызовем функцию f1(a, 4) , то увидим, что значения массива действительно поменялись. НО: если мы посмотрим содержимое массива a в main - то обнаружим обратное - ничего не изменилось. Так в чем же причина? Все предельно просто: в функции f3 мы работали не с самим указателем a , а с его локальной копией! Все изменения, которые произошли в функции f3 - затронули только локальную копию указателя, но никак не сам указатель a . Давайте посмотрим на следующий пример:

   Void false_eqv(int, int); void main(){ int a = 3, b = 5; false_eqv(a, b); // Поменялось значение a? // Конечно же, нет } false_eqv(int a, int b){ a = b; } Итак, я думаю, вы поняли, к чему я веду. Переменной a нельзя присвоить таким образом значение переменной b - ведь мы передавали их значения напрямую, а не по ссылке. То же самое и с указателями - используя их в качестве аргументов таким образом, мы заведомо лишаем их возможности изменения значения.
   Вариант третий, или работа над ошибками по второму варианту:

   Void f4(int***, int**); void main(){ const int size = 4; int** a = new int*; int** b = new int*; for (int i = 0; i != 4; i++){ a[i] = new int; b[i] = new int; for (int j = 0; j != 4; j++){ a[i][j] = i * j + 1; b[i][j] = i * j - 1; } } int*** d = &a; f4(d, b); } void f4(int*** a, int** b){ *a = b; }
   Таким образом, в main"е мы создаем указатель d на указатель a , и именно его передаем в качестве аргумента в функцию замены. Теперь, разыменовав d внутри f4 и приравняв ему значение указателя b , мы заменили значение настоящего указателя a , а не его локальной копии, на значение указателя b .

   Кстати, а чего это мы создаем динамические объекты? Ну ладно размер массива не знали, а экземпляры классов мы зачем динамическими делали? Да потому что зачастую, созданный нами объекты свое - они генерились, порождали новые данные/объекты для дальнейшей работы, а теперь пришло им время... умереть [фу, как грубо] уйти со сцены. И как мы это сделаем? Просто:

   Delete(a); delete(b); // Вот и кончились наши двумерные массивы delete(v); // Вот и нет больше двумерного массива с динамическими объектами delete(dyn_array); // Вот и удалился одномерный массив

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

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

Что такое указатели и зачем они нужны?

Указатели похожи на метки, которые ссылаются на места в памяти. Представьте сейф с депозитными ячейками различного размера в местном банке. Каждая ячейка имеет номер, уникальный номер, который связан только с этой ячейкой, таким образом можно быстро идентифицировать нужную ячейку. Эти цифры аналогичны адресам ячеек компьютерной памяти. К примеру, у вас есть богатый дядя, который хранит все свои ценности в своем сейфе. И чтобы обезопасить все свои сбережения, он решил завести меньший сейф, в который положит карту, на которой показано местоположение большого сейфа и указан 16-й пароль от большого сейфа, в котором и хранятся реальные драгоценности. По сути, сейф с картой будет хранить расположение другого сейфа. Вся эта организация сбережения драгоценностей эквивалентна указателям в языке Си. В компьютере, указатели просто переменные, которые хранят адреса памяти, как правило, адреса других переменных.

Идея в том, что зная адрес переменной, вы можете пойти по этому адресу и получить данные, хранящиеся в нем. Если вам нужно передать огромный кусок данных в функцию, намного проще передать адрес в памяти, по которому хранятся эти данные, чем скопировать каждый элемент данных! Более того, если программе понадобится больше памяти, вы можете запросить больше памяти из системы. Как же это работает? Система просто возвращает адрес ячейки памяти, и мы должны сохранить этот адрес в переменной-указателе. Так мы сможем взаимодействовать с данными из указанного участка памяти.

Синтаксис указателей

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

Data_type *pointerName;

где, data_type — тип данных, pointerName — имя указателя.

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

Int *integerPointer;

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

// Объявление указателя и простой переменной в одной строке int *pointer1, // это указатель variable; // это обычная переменная типа int // Объявление двух указателей в одно строке int *pointer1, // это указатель с именем pointer1 *pointer2; // это указатель с именем pointer2

Как я и говорил, если имя переменной не предваряется символом * , то это обычная переменная, в противном случае — это указатель. Именно это и показывает пример объявления указателей, выше.

Есть два способа использования указателя:

1. Использовать имя указателя без символа * , таким образом можно получить фактический адрес ячейки памяти, куда ссылается указатель.
2. Использовать имя указателя с символом * , это позволит получить значение, хранящееся в памяти. В рамках указателей, у символа * есть техническое название — операция разыименования. По сути, мы принимаем ссылку на какой-то адрес памяти, чтобы получить фактическое значение. Это может быть сложно для понимания, но в дальнейшем постараемся разобраться во всем этом.

Объявление указателя, получение адреса переменной

Для того чтобы объявить указатель, который будет ссылаться на переменную, необходимо сначала получить адрес этой переменной. Чтобы получить адрес памяти переменной (её расположение в памяти), нужно использовать знак & перед именем переменной. Это позволяет узнать адрес ячейки памяти, в которой хранится значение переменной. Эта операция называется — операция взятия адреса и выглядит вот так:

Int var = 5; // простое объявление переменной с предварительной инициализацией int *ptrVar; // объявили указатель, однако он пока ни на что не указывает ptrVar = &var; // теперь наш указатель ссылается на адрес в памяти, где хранится число 5

В строке 3 использовалась операция взятия адреса, мы взяли адрес переменной var и присвоили его указателю ptrVar . Давайте рассмотрим программу, которая наглядно покажет всю мощь указателей. Итак, вот исходник:

#include int main() { int var; // обычная целочисленная переменная int *ptrVar; // целочисленный указатель (ptrVar должен быть типа int, так как он будет ссылаться на переменную типа int) ptrVar = &var; // присвоили указателю адрес ячейки в памяти, где лежит значение переменной var scanf("%d", &var); // в переменную var положили значение, введенное с клавиатуры printf("%d\n", *ptrVar); // вывод значения через указатель getchar(); }

Результат работы программы:

В строке 10 , printf() выводит значение, хранящееся в переменной var . Почему так происходит? Что ж, давайте посмотрим на код. В строке 5 , мы объявили переменную var типа int . В строке 6 — указатель ptrVar на целое значение. Затем указателю ptrVar присвоили адрес переменной var , для этого мы воспользовались оператором присвоения адреса. Затем пользователь вводит номер, который сохраняется в переменную var , помните, что это то же самое место, на которое указывает ptrVar . В самом деле, так как мы используем амперсанд чтобы присвоить значение переменной var в функции scanf() , должно быть понятно, что scanf() инициализирует переменную var через адрес. На этот же адрес указывает указатель ptrVar .

Затем, в строке 10 , выполняется операция «разыменования» — *ptrVar . Программа, через указатель ptrVar , считывает адрес, который хранится в указателе, по адресу попадает в нужную ячейку памяти, и возвращает значение, которое там хранится.

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

Если бы такие приемчики были позволены в ОС, вы могли бы получить доступ к любому участку памяти. А это значит, что для любой запущенной программы вы могли бы внести свои изменения, например, если у вас открыт документ в Word, вы могли бы изменить любой текст программно. К счастью, Windows и другие современные операционные системы остановит вас от доступа к этой памяти и преждевременно закроют вашу программу.

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

P.S.:Если у вас нет денег на телефоне, и нет возможности его пополнить, но при этом, вам срочно нужно позвонить, вы всегда можете использовать доверительный платеж билайн . Сумма доверительного платежа может быть самой разнообразной, от 50 до 300р.