Указатели это чрезвычайно мощный инструмент в программировании. С помощью указателей некоторые вещи в программировании можно сделать намного проще и при этом эффективность работы вашей программы значительно повысится. Указатели даже позволяют обрабатывать неограниченное количество данных. Например, с помощью указателей можно изменять значения переменных внутри функции, при этом переменные передаются в функцию в качестве параметров. Кроме того, указатели можно использовать для динамического выделения памяти, что означает, что вы можете писать программы, которые могут обрабатывать практически неограниченные объемы данных на лету — вам не нужно знать, когда вы пишете программу, сколько памяти нужно выделить заранее. Пожалуй, это самая мощная функция указателей. Для начала давайте просто получим общее представление об указателях, научимся их объявлять и использовать.
Что такое указатели и зачем они нужны?
Указатели похожи на метки, которые ссылаются на места в памяти. Представьте сейф с депозитными ячейками различного размера в местном банке. Каждая ячейка имеет номер, уникальный номер, который связан только с этой ячейкой, таким образом можно быстро идентифицировать нужную ячейку. Эти цифры аналогичны адресам ячеек компьютерной памяти. К примеру, у вас есть богатый дядя, который хранит все свои ценности в своем сейфе. И чтобы обезопасить все свои сбережения, он решил завести меньший сейф, в который положит карту, на которой показано местоположение большого сейфа и указан 16-й пароль от большого сейфа, в котором и хранятся реальные драгоценности. По сути, сейф с картой будет хранить расположение другого сейфа. Вся эта организация сбережения драгоценностей эквивалентна указателям в языке Си. В компьютере, указатели просто переменные, которые хранят адреса памяти, как правило, адреса других переменных.
Идея в том, что зная адрес переменной, вы можете пойти по этому адресу и получить данные, хранящиеся в нем. Если вам нужно передать огромный кусок данных в функцию, намного проще передать адрес в памяти, по которому хранятся эти данные, чем скопировать каждый элемент данных! Более того, если программе понадобится больше памяти, вы можете запросить больше памяти из системы. Как же это работает? Система просто возвращает адрес ячейки памяти, и мы должны сохранить этот адрес в переменной-указателе. Так мы сможем взаимодействовать с данными из указанного участка памяти.
Синтаксис указателей
Если у нас есть указатель, значит мы можем получить его адрес в памяти и данные на которые он ссылается, по этой причине указатели имеют несколько необычный синтаксис, отличающийся от объявления простых переменных. Более того, поскольку указатели — это не обычные переменные, то, необходимо сообщить компилятору, что переменная является указателем и сообщить компилятору тип данных, на которые ссылается указатель. Итак, указатель объявляется следующим образом:
Data_type *pointerName;
где, data_type — тип данных, pointerName — имя указателя.
Например, объявим указатель, который хранит адрес ячейки памяти, в которой лежит целое число:
Int *integerPointer;
Обратите внимание на использование символа * , при объявлении указателя. Этот символ является ключевым в объявлении указателя. Если в объявлении переменной, непосредственно перед именем переменной, добавить этот символ, то переменная будет объявлена как указатель. Кроме того, если вы объявляете несколько указателей в одной строке, каждый из них должен предваряться символом звездочки. Рассмотрим несколько примеров:
// Объявление указателя и простой переменной в одной строке int *pointer1, // это указатель variable; // это обычная переменная типа int // Объявление двух указателей в одно строке int *pointer1, // это указатель с именем pointer1 *pointer2; // это указатель с именем pointer2
Как я и говорил, если имя переменной не предваряется символом * , то это обычная переменная, в противном случае — это указатель. Именно это и показывает пример объявления указателей, выше.
Есть два способа использования указателя:
- Использовать имя указателя без символа * , таким образом можно получить фактический адрес ячейки памяти, куда ссылается указатель.
- Использовать имя указателя с символом * , это позволит получить значение, хранящееся в памяти. В рамках указателей, у символа * есть техническое название — операция разыименования. По сути, мы принимаем ссылку на какой-то адрес памяти, чтобы получить фактическое значение. Это может быть сложно для понимания, но в дальнейшем постараемся разобраться во всем этом.
Объявление указателя, получение адреса переменной
Для того чтобы объявить указатель, который будет ссылаться на переменную, необходимо сначала получить адрес этой переменной. Чтобы получить адрес памяти переменной (её расположение в памяти), нужно использовать знак & перед именем переменной. Это позволяет узнать адрес ячейки памяти, в которой хранится значение переменной. Эта операция называется — операция взятия адреса и выглядит вот так:
Int var = 5; // простое объявление переменной с предварительной инициализацией int *ptrVar; // объявили указатель, однако он пока ни на что не указывает ptrVar = &var; // теперь наш указатель ссылается на адрес в памяти, где хранится число 5
В строке 3 использовалась операция взятия адреса, мы взяли адрес переменной var и присвоили его указателю ptrVar . Давайте рассмотрим программу, которая наглядно покажет всю мощь указателей. Итак, вот исходник:
#include
Результат работы программы:
В строке 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р.
Даже если большинство программистов понимают, в чем разница между объектами и указателями на них, иногда бывает не совсем понятно, в пользу какого из способов обращения к объекту стоит делать выбор. Ниже мы постарались ответить на этот вопрос.
Вопрос
Я заметил, что нередко программисты, чей код я видел, используют указатели на объекты чаще, чем сами эти объекты, т.е., например, используют следующую конструкцию:
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 . Если библиотека использует память, которая впоследствии должна быть освобождена вручную, вы можете оформить деструктор в умном указателе.
Указатель – переменная, значением которой является адрес ячейки памяти. То есть указатель ссылается на блок данных из области памяти, причём на самое его начало. Указатель может ссылаться на переменную или функцию. Для этого нужно знать адрес переменной или функции. Так вот, чтобы узнать адрес конкретной переменной в С++ существует унарная операция взятия адреса & . Такая операция извлекает адрес объявленных переменных, для того, чтобы его присвоить указателю.
Указатели используются для передачи по ссылке данных, что намного ускоряет процесс обработки этих данных (в том случае, если объём данных большой), так как их не надо копировать, как при передаче по значению, то есть, используя имя переменной. В основном указатели используются для организации динамического распределения памяти, например при объявлении массива, не надо будет его ограничивать в размере. Ведь программист заранее не может знать, какого размера нужен массив тому или иному пользователю, в таком случае используется динамическое выделение памяти под массив. Любой указатель необходимо объявить перед использованием, как и любую переменную.
//объявление указателя /*тип данных*/ * /*имя указателя*/;
Принцип объявления указателей такой же, как и принцип объявления переменных. Отличие заключается только в том, что перед именем ставится символ звёздочки * . Визуально указатели отличаются от переменных только одним символом. При объявлении указателей компилятор выделяет несколько байт памяти, в зависимости от типа данных отводимых для хранения некоторой информации в памяти. Чтобы получить значение, записанное в некоторой области, на которое ссылается указатель нужно воспользоваться операцией разыменования указателя * . Необходимо поставить звёздочку перед именем и получим доступ к значению указателя. Разработаем программу, которая будет использовать указатели.
// pointer1.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
// pointer1.cpp: определяет точку входа для консольного приложения.
#include
В строке 10 объявлен и инициализирован адресом переменной var указатель ptrvar . Можно было сначала просто объявить указатель, а потом его инициализировать, тогда были бы две строки:
Int *ptrvar; // объявление указателя ptrvar = &var; // инициализация указателя
В программировании принято добавлять к имени указателя приставку ptr , таким образом, получится осмысленное имя указателя, и уже с обычной переменной такой указатель не спутаешь. Результат работы программы (см. Рисунок 1).
&var = 0x22ff08 ptrvar = 0x22ff08 var = 123 *ptrvar = 123 Для продолжения нажмите любую клавишу. . .
Рисунок 1 — Указатели в С++
Итак, программа показала, что строки 11 и 12 выводят идентичный адрес, то есть адрес переменной var , который содержится в указателе ptrvar . Тогда как операция разыменования указателя *ptrvar обеспечивает доступ к значению, на которое ссылается указатель.
Указатели можно сравнивать не только на равенство или неравенство, ведь адреса могут быть меньше или больше относительно друг друга. Разработаем программу, которая будет сравнивать адреса указателей.
"stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
// pointer.cpp: определяет точку входа для консольного приложения.
#include
Результат работы программы показан на рисунке 2.
Var1 = 123 var2 = 99 ptrvar1 = 0x22ff04 ptrvar2 = 0x22ff00 ptrvar1 > ptrvar2 *ptrvar1 > *ptrvar2 Для продолжения нажмите любую клавишу. . .
Рисунок 2 — Указатели в С++
В первом случае, мы сравнивали адреса переменных, и, причём адрес второй переменной, всегда меньше адреса первой переменной. При каждом запуске программы адреса выделяются разные. Во втором случае мы сравнивали значения этих переменных используя операцию разыменования указателя.
Из арифметических операций, чаще всего используются операции сложения, вычитания, инкремент и декремент, так как с помощью этих операций, например в массивах, вычисляется адрес следующего элемента.
Указатели на указатели
Указатели могут ссылаться на другие указатели. При этом в ячейках памяти, на которые будут ссылаться первые указатели, будут содержаться не значения, а адреса вторых указателей. Число символов * при объявлении указателя показывает порядок указателя. Чтобы получить доступ к значению, на которое ссылается указатель его необходимо разыменовывать соответствующее количество раз. Разработаем программу, которая будет выполнять некоторые операции с указателями порядка выше первого.
// код Code::Blocks
// код Dev-C++
// pointer.cpp: определяет точку входа для консольного приложения.
#include
На рисунке 3 показан результат работы программы.
Var = 123 *ptrvar = 123 **ptr_ptrvar = 123 ***ptr_ptrvar = 123 ***ptr_ptr_ptrvar -> **ptr_ptrvar -> *ptrvar -> var -> 123 0x22ff00 -> 0x22ff04 ->0x22ff08 -> 0x22ff0c -> 123 Для продолжения нажмите любую клавишу. . .
Рисунок 3 — Указатели в С++
Данная программа доказывает тот факт, что для получения значения количество разыменований указателя должно совпадать с его порядком. Логика n-кратного разыменования заключается в том, что программа последовательно перебирает адреса всех указателей вплоть до переменной, в которой содержится значение. В программе показана реализация указателя третьего порядка. И если, используя такой указатель (третьего порядка) необходимо получить значение, на которое он ссылается, делается 4 шага:
- по значению указателя третьего порядка получить адрес указателя второго порядка;
- по значению указателя второго порядка получить адрес указателя первого порядка;
- по значению указателя первого порядка получить адрес переменной;
- по адресу переменной получить доступ к её значению.
Данные четыре действия показаны на рисунке 3 (две предпоследние строки). Верхняя строка показывает имена указателей, а нижняя строка их адреса.
На рисунке 4 показана схема разыменовывания указателя третьего порядка из верхней программы. Суть в том, что указатели связаны друг с другом через свои адреса. Причём, например, для указателя ptr_ptrvar данное число 0015FDB4 является адресом, а для указателя ptr_ptr_ptrvar это же число является значением.
Рисунок 4 — Указатели в С++
Именно таким образом выполняется связка указателей. Вообще говоря, указатели порядка выше первого используются редко, но данный материал поможет понять механизм работы указателей.
Указатели на функции
Указатели могут ссылаться на функции. Имя функции, как и имя массива само по себе является указателем, то есть содержит адрес входа.
// объявление указателя на функцию /*тип данных*/ (* /*имя указателя*/)(/*список аргументов функции*/);
Тип данных определяем такой, который будет возвращать функция, на которую будет ссылаться указатель. Символ указателя и его имя берутся в круглые скобочки, чтобы показать, что это указатель, а не функция, возвращающая указатель на определённый тип данных. После имени указателя идут круглые скобки, в этих скобках перечисляются все аргументы через запятую как в объявлении прототипа функции. Аргументы наследуются от той функции, на которую будет ссылаться указатель. Разработаем программу, которая использует указатель на функцию. Программа должна находить НОД – наибольший общий делитель. НОД – это наибольшее целое число, на которое без остатка делятся два числа, введенных пользователем. Входные числа также должны быть целыми.
// pointer_onfunc.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
// pointer_onfunc.cpp: определяет точку входа для консольного приложения.
#include
Данная задача решена рекурсивно, чтоб уменьшить объём кода программы, по сравнению с итеративным решением этой же задачи. В строке 9 объявляется указатель, которому в строке 10 присвоили адрес функции. Как мы уже говорили до этого, адресом функции является просто её имя. То есть данный указатель теперь указывает на функцию nod() . При объявлении указателя на функцию ни в коем случае не забываем о скобочках, в которые заключаются символ указателя и его имя. При объявлении указателя в аргументах указываем то же самое, что и в прототипе указываемой функции. Результат работы программы (см. Рисунок 5).
Enter first number: 16 Enter second number: 20 NOD = 4 Для продолжения нажмите любую клавишу. . .
Рисунок 5 — Указатели в С++
Вводим первое число, затем второе и программа выдает НОД. На рисунке 5 видно, что НОД для чисел 16 и 20 равен четырём.
Указатель - это переменная, содержащая адрес некоторого объекта в оперативной памяти (ОП). Смысл применения указателей - косвенная адресация объектов в ОП, позволяющая динамически менять логику программы и управлять распределением ОП.
Основные применения:
- работа с массивами и строками;
- прямой доступ к ОП;
- работа с динамическими объектами, под которые выделяется ОП.
Описание указателя имеет следующий общий вид:
Тип *имя;
то есть, указатель всегда адресует определённый тип объектов ! Например,
Int *px; // указатель на целочисленные данные char *s; //указатель на тип char (строку Си)
Опишем основные операции и действия, которые разрешены с указателями:
1. Сложение/вычитание с числом:
Px++; //переставить указатель px на sizeof(int) байт вперед s--; //перейти к предыдущему символу строки //(на sizeof(char) байт, необязательно один)
2. Указателю можно присваивать адрес объекта унарной операцией " & ":
Int *px; int x,y; px=&x; //теперь px показывает на ячейку памяти со // значением x px=&y; //а теперь – на ячейку со значением y
3. Значение переменной, на которую показывает указатель, берется унарной операцией " * " ("взять значение"):
X=*px; //косвенно выполнили присваивание x=y (*px)++; //косвенно увеличили значение y на 1
Важно ! Из-за приоритетов и ассоциативности операций C++ действие
имеет совсем другой смысл, чем предыдущее. Оно означает "взять значение y (*px) и затем перейти к следующей ячейке памяти (++)"
Расшифруем оператор
Если px по-прежнему показывал на y , он означает "записать значение y в x и затем перейти к ячейке памяти, следующей за px ". Именно такой подход в классическом Си используется для сканирования массивов и строк.
Вот пример, с точностью до адресов памяти показывающий это важное различие. Комментарием приведены значения и адреса памяти переменных x и y , а также значение, полученное по указателю px и адрес памяти, на который он показывает. Обратите внимание, что после выполнения второго варианта кода значение, полученное по указателю, стало "мусором", так как он показывал на переменную, а не на нулевой элемент массива.
#include
Приведём пример связывания указателя со статическим массивом:
Int a={1,2,3,4,5}; int *pa=&a; for (int i=0; i<5; i++) cout
For (int i=0; i<5; i++) cout
Эти записи абсолютно эквиваленты, потому что в Си конструкция a[b] означает не что иное, как *(a+b) , где a - объект, b – смещение от начала памяти, адресующей объект. Таким образом, обращение к элементу массива a[i] может быть записано и как *(a+i) , а присваивание указателю адреса нулевого элемента массива можно бы было записать в любом из 4 видов
Int *pa=&a; int *pa=&(*(a+0)); int *pa=&(*a); int *pa=a;
Важно ! При любом способе записи это одна и та же операция, и это - не "присваивание массива указателю", это его установка на нулевой элемент массива.
4. Сравнение указателей (вместо сравнения значений, на которые они указывают) в общем случае может быть некорректно !
Int x; int *px=&x, *py=&x; if (*px==*py) ... //корректно if (px==py) ... //некорректно!
Причина – адресация ОП не обязана быть однозначной, например, в DOS одному адресу памяти могли соответствовать разные пары частей адреса "сегмент" и "смещение".
Способ 1, со ссылочной переменной C++
Void swap (int &a, int &b) { int c=a; a=b; b=c; } //... int a=3,b=5; swap (a,b);
Этот способ можно назвать "передача параметров по значению, приём по ссылке".
Способ 2, с указателями Cи
Void swap (int *a, int *b) { int c=*a; *a=*b; *b=c; } //... int a=3,b=5; swap (&a,&b); int *pa=&a; swap (pa,&b);
Передача параметров по адресу, прием по значению.
Указатели и строки языка Си
Как правило, для сканирования Си-строк используются указатели.
Char *s="Hello, world";
Это установка указателя на первый байт строковой константы, а не копирование и не присваивание!
Важно !
1. Даже если размер символа равен одному байту, эта строка займёт не 12 (11 символов и пробел), а 13 байт памяти. Дополнительный байт нужен для хранения нуль-терминатора, символа с кодом 0 , записываемого как "\0" (но не "0" – это цифра 0 с кодом 48). Многие функции работы с Си-строками автоматически добавляют нуль-терминатор в конец обрабатываемой строки:
Char s; strcpy(s,"Hello, world"); //Вызвали стандартную функцию копирования строки //Ошибка! Нет места для нуль-терминатора сhar s; //А так было бы верно!
2. Длина Си-строки нигде не хранится, её можно только узнать стандартной функцией strlen(s) , где s – указатель типа char * . Для строки, записанной выше, будет возвращено значение 12, нуль-терминатор не считается. Фактически, Си-строка есть массив символов, элементов типа char .
Как выполнять другие операции со строками, заданными c помощью указателей char * ? Для этого может понадобиться сразу несколько стандартных библиотек. Как правило, в новых компиляторах C++ можно подключать и "классические" си-совместимые заголовочные файлы, и заголовки из более новых версий стандарта, которые указаны в скобках.
Файл ctype.h (cctype) содержит:
1) функции с именами is* - проверка класса символов (isalpha , isdigit , ...), все они возвращают целое число, например:
Char d; if (isdigit(d)) { //код для ситуации, когда d - цифра }
Аналогичная проверка "вручную" могла бы быть выполнена кодом вида
If (d>="0" && d<="9") {
2) функции с именами to* - преобразование регистра символов (toupper , tolower), они возвращают преобразованный символ. Могут быть бесполезны при работе с символами национальных алфавитов, а не только латиницей.
Модуль string.h (cstring) предназначен для работы со строками, заданными указателем и заканчивающимися байтом "\0" ("строками Си"). Имена большинства его функций начинаются на "str". Часть функций (memcpy , memmove , memcmp) подходит для работы с буферами (областями памяти с известным размером).
Примеры на работу со строками и указателями
1. Копирование строки
Char *s="Test string"; char s2; strcpy (s2,s); //копирование строки, s2 - буфер, а не указатель!
2. Копирование строки с указанием количества символов
Char *s="Test string"; char s2; char *t=strncpy (s2,s,strlen(s)); cout << t;
Функция strncpy копирует не более n символов (n - третий параметр), но не запишет нуль-терминатор, в результате чего в конце строки t выведется "мусор". Правильно было бы добавить после вызова strncpy следующее:
T="\0";
то есть, "ручную" установку нуль-терминатора.
3. Копирование строки в новую память
Char *s="12345"; char *s2=new char ; strcpy (s2,s);
Здесь мы безопасно скопировали строку s в новую память s2 , не забыв выделить "лишний" байт для нуль-терминатора.
4. Приведём собственную реализацию стандартной функции strcpy:
Char *strcpy_ (char *dst, char *src) { char *r=dst; while (*src!="\0") { *dst=*src; dst++; src++; } *dst="\0"; return r; }
Вызвать нашу функцию можно, например, так:
Char *src="Строка текста"; char dst; strcpy_ (&dst,&src);
Сократим текст функции strcpy_:
Char *strcpy_ (char *dst, char *src) { char *r=dst; while (*src) *dst++=*src++; *dst="\0"; return r; }
5. Сцепление строк – функция strcat
Char *s="Test string"; char *s2; char *t2=strcat (s2,strcat(s," new words"));
Так как strcat не выделяет память, поведение такого кода непредсказуемо!
А вот такое сцепление строк сработает:
Char s; strcpy (s,"Test string"); char s2; strcat (s," new words"); strcpy (s2,s); char *t2=strcat (s2,s);
То есть, всегда должна быть память, куда писать - статическая из буфера или выделенная динамически.
6. Поиск символа или подстроки в строке.
Char *sym = strchr (s,"t"); if (sym==NULL) puts ("Не найдено"); else puts (sym); //выведет "t string" //для strrchr вывод был бы "tring" char *sub = strstr (s,"ring"); puts (sub); //выведет "ring"
7. Сравнение строк – функции с шаблоном имени str*cmp - "string comparing"
Char *a="abcd",*b="abce"; int r=strcmp(a,b); //r=-1, т.к. символ "d" предшествует символу "e" //Соответственно strcmp(b,a) вернет в данном случае 1 //Если строки совпадают, результат=0
8. Есть готовые функции для разбора строк - strtok , strspn , strсspn - см. пособие, пп. 8.1-8.3
9. Преобразование типов между числом и строкой - библиотека stdlib.h (cstdlib)
Char *s="qwerty"; int i=atoi(s); //i=0, исключений не генерируется!
Из числа в строку:
1) itoa , ultoa - из целых типов
Char buf; int i=-31189; char *t=itoa(i,buf,36); //В buf получили запись i в 36-ричной с.с.
2) fcvt , gcvt , ecvt - из вещественных типов
Работа с динамической памятью
Как правило, описывается указатель нужного типа, который затем связывается с областью памяти, выделенной оператором new или си-совместимыми функциями для управления ОП.
1. Описать указатель на будущий динамический объект:
Int *a; //Надёжнее int *a=NULL;
2. Оператором new или функциями malloc , calloc выделить оперативную память:
A = new int ;
#include
A = (int *) calloc (10,sizeof(int));
В последнем случае мы выделили 10 элементов по sizeof(int) байт и заполнили нулями "\0" .
Важно ! Не смешивайте эти 2 способа в одном программном модуле или проекте! Предпочтительней new , кроме тех случаев, когда нужно обеспечить заполнение памяти нулевыми байтами.
3. Проверить, удалось ли выделить память - если нет, указатель равен константе константе NULL из стандартной библиотеки (в ряде компиляторов null , nullptr , 0):
If (a==NULL) { //Обработка ошибка "Не удалось выделить память" }
4. Работа с динамическим массивом или строкой ничем не отличается от случая, когда они статические.
5. Когда выделенная ОП больше не нужна, её нужно освободить:
Delete a; //Если использовали new free (a); //Пытается освободить ОП, //если использовали malloc/calloc
Важно ! Всегда старайтесь придерживаться принципа стека при распределении ОП. То есть, объект, занявший ОП последним, первым её освобождает.
Пример. Динамическая матрица размером n*m.
Const int n=5,m=4;
int **a = new (int *) [n];
for (int i=0; i После этого можно работать с элементами матрицы a[i][j] , например, присваивать им значения. Освободить память можно было бы так: For (int i=n-1; i>-1; i--) delete a[i];
delete a;
1. Написать собственную функцию работы со строкой, заданной указателем, сравнить со стандартной. 2. Написать собственную функцию для работы с одномерным динамическим массивом, заданным указателем. 3. Написать свои версии функций преобразования строки в число и числа в строку. Объявление и
инициализация переменной-указателя.
Указатели представляют собой переменные,
значениями которых являются адреса
памяти. Указатель содержит адрес
переменной, в которой находится конкретное
значение. Переменная непосредственно
ссылается на значение, а указатель
косвенно ссылается на значение. Ссылка
на значение через посредство указателя
называется косвенной адресацией. Указатели,
как и любые другие переменные, должны
быть объявлены, прежде чем они будут
использоваться. В
операторе 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. Какая операция
используется для организации вызова
по ссылке?
