Пожалуйста, приостановите работу AdBlock на этом сайте.
Указатель – переменная, в которой хранится адрес какого-либо объекта в памяти компьютера, например, другой переменной. Мы уже сталкивались раньше с адресами переменных, когда изучали функцию scanf.
Итак, пойдём по порядку. Объявление указателя.
Объявление указателя отличается от объявления переменной только добавлением символа * после названия типа. Примеры:
Листинг 1.
int * p_g; // указатель на переменную типа int double * p_f; // указатель на переменную типа double
Присвоить указателю какой-то адрес можно, используя оператор присваивания. Примеры:
Листинг 2.
int n = 100; double PI = 3.1415926; int * p_k; // указатель на переменную типа int double * p_pi; // указатель на переменную типа double p_k = &n; // получаем адрес переменной n и присваиваем его указателю p_k p_pi = Π // получаем адрес переменной PI и присваиваем его указателю p_pi
Для вывода значения указателя на экран нужно в функции printf использовать модификатор %p. Пример:
Листинг 3.
printf ("adres peremennoi PI %p\n", p_pi);
Используя адрес переменной, который хранится в указателе, можно изменять значения этой переменной. Для этого используется операция разыменования *. Вот посмотрите на пример:
Листинг 4.
#include
Рис.1 Доступ к переменной через указатель
Итого, * применительно к указателям используется в двух случаях:
Есть еще, так называемый, нулевой указательNULL. Нулевой указатель не ссылается никуда. Он используется, чтобы обнулять указатели. Посмотрите на пример.
Листинг 5.
#include
Рис.2 Обнуление указателя
На главную
Язык Си на примерах
Функции в Си применяются для выполнения определённых действий в рамках общей программы. Программист сам решает какие именно действия вывести в функции. Особенно удобно применять функции для многократно повторяющихся действий.
Пример функции в Cи:
Это очень простая программа на Си. Она просто выводит строку «Functions in C». В программе имеется единственная функция под названием main. Рассмотрим эту функцию подробно. В заголовке функции, т.е. в строке
int – это тип возвращаемого функцией значения;
main - это имя функции;
(void) - это перечень аргументов функции. Слово void указывает, что у данной функции нет аргументов;
return – это оператор, который завершает выполнение функции и возвращает результат работы функции в точку вызова этой функции;
EXIT_SUCCESS - это значение, равное нулю. Оно определено в файле stdlib.h;
часть функции после заголовка, заключенная в фигурные скобки
{
puts(«Functions in C»);
return EXIT_SUCCESS;
}
называют телом функции.
Итак, когда мы работаем с функцией надо указать имя функции, у нас это main, тип возвращаемого функцией значения, у нас это int, дать перечень аргументов в круглых скобках после имени функции, у нас нет аргументов, поэтому пишем void, в теле функции выполнить какие-то действия (ради них и создавалась функция) и вернуть результат работы функции оператором return. Вот основное, что нужно знать про функции в C.
Рассмотрим пример вызова функций в Си:
Запускаем на выполнение и получаем:
В этом примере создана функция sum, которая складывает два целых числа и возвращает результат. Разберём подробно устройство этой функции.
Заголовок функции sum:
int sum(int a, int b)
здесь int - это тип возвращаемого функцией значения;
sum - это имя функции;
(int a, int b) - в круглых скобках после имени функции дан перечень её аргументов: первый аргумент int a, второй аргумент int b. Имена аргументов являются формальными, т.е. при вызове функции мы не обязаны отправлять в эту функцию в качестве аргументов значения перемнных с именами a и b. В функции main мы вызываем функцию sum так: sum(d, e);. Но важно, чтоб переданные в функцию аргументы совпадали по типу с объявленными в функции.
В теле функции sum, т.е. внутри фигурных скобок после заголовка функции, мы создаем локальную переменную int c, присваиваем ей значение суммы a плюс b и возвращаем её в качестве результата работы функции опрератором return.
Теперь посмотрим как функция sum вызывается из функции main.
Вот функция main:
Сначала мы создаём две переменных типа int
int d = 1; int e = 2;
их мы передадим в функцию sum в качестве значений аргументов.
int f = sum(d, e);
её значением будет результат работы функции sum, т.е. мы вызываем функцию sum, которая возвратит значение типа int, его-то мы и присваиваем переменной f. В качестве аргументов передаём d и f. Но в заголовке функции sum
int sum(int a, int b)
аргументы называются a и b, почему тогда мы передаем d и f? Потому что в заголовке функций пишут формальные аргументы, т.е. НЕ важны названия аргументов, а важны их типы. У функции sum оба аргумента имеют тип int, значит при вызове этой функции надо передать два аргумента типа int с любыми названиями.
Ещё одна тонкость. Функция должна быть объявлена до места её первого вызова. В нашем примере так и было: сначала объявлена функция sum, а уж после мы вызываем её из функции main. Если функция объявляется после места её вызова, то следует использовать прототип функции.
Рассмотрим пример функциив Си:
В этом примере функция sum определена ниже места её вызова в функции main.
В таком случае надо использовать прототип функции sum. Прототип у нас объявлен выше функции main:
int sum(int a, int b);
Прототип - это заголовок функции, который завершается точкой с запятой. Прототип - это объявление функции, которая будет ниже определена. Именно так у нас и сделано: мы объявили прототип функции
int f = sum(d, e);
а ниже функции main определяем функцию sum, которая предварительно была объявлена в прототипе:
Когда мы пишем прототип функции, например так:
int sum(int a, int b);
то мы объявляем функцию.
А когда мы реализуем функцию, т.е. записываем не только заголовок, но и тело функции, например:
то мы определяем функцию.
Оператор return завершает работу функции в C и возвращает результат её работы в точку вызова. Пример:
Эту функцию можно упростить:
здесь оператор return вернёт значение суммы a + b.
Операторов return в одной функции может быть несколько. Пример:
Если в примере значение аргумента a окажется больше двух, то функция вернет ноль (первый случай) и всё, что ниже комментария «// Первый случай;» выполнятся не будет.
Если a будет меньше двух, но b будет меньше нуля, то функция завершит свою работу и всё, что ниже комментария «// Второй случай;» выполнятся не будет.
И только если оба предыдущих условия не выполняются, то выполнение программы дойдёт до последнего оператора return и будет возвращена сумма a + b.
Аргументы можно передавать в функцию C по значению. Пример:
В примере, в функции main, создаём переменную int d = 10. Передаём по значению эту переменную в функцию sum(d). Внутри функции sum значение переменной увеличивается на 5. Но в функции main значение d не изменится, ведь она была передана по значению. Это означает, что было передано значение переменной, а не сама переменная. Об этом говорит и результат работы программы:
т.е. после возврата из функции sum значеие d не изменилось, тогда как внутри функции sum оно менялось.
Если в качестве аргумента функции передавать вместо значения переменной указатель на эту переменную, то значение этой переменной может меняться. Для примера берём программу из предыдущего раздела, несколько изменив её:
В этом варианте программы я перешел от передачи аргумента по значению к передаче указателя на переменную. Рассмотрим подробнее этот момент.
printf(«sum = %d\n», sum(&d));
в функцию sum передается не значение переменной d, равное 10-ти, а адрес этой переменной, вот так:
Теперь посмотрим на функцию sum:
Аргументом её является указатель на int. Мы знаем, что указатель - это переменная, значением которой является адрес какого-то объекта. Адрес переменной d отправляем в функцию sum:
Внутри sum указатель int *a разыменовывается. Это позволяет от указателя перейти к самой переменной, на которую и указывает наш указатель. А в нашем случае это переменная d, т.е. выражение
равносильно выражению
Результат: функция sum изменяет значение переменной d:
На этот раз изменяется значение d после возврата из sum, чего не наблюдалось в предыдущм пункте, когда мы передавали аргумент по значению.
Все примеры для этой статьи я сделал в Eclipse. Как работать с C/C++ в Eclipse можно посмотреть здесь. Если вы работаете в другой среде, то примеры и там будут работать.
Теги: Си указатели. Указатель на указатель. Тип указателя. Арифметика указателей. Сравнение указателей.
Это, пожалуй, самая сложная и самая важная тема во всём курсе. Без понимания указателей дальнейшее изучении си будет бессмысленным. Указатели – очень простая концепция, очень логичная, но требующая внимания к деталям.
Указатель – это переменная, которая хранит адрес области памяти.
Указатель, как и переменная, имеет тип. Синтаксис объявления указателей
<тип> *<имя>;
Например
Два основных оператора для работы с указателями – это оператор & взятия адреса, и оператор * разыменования. Рассмотрим простой пример.
#include
Рассмотрим код внимательно, ещё раз
Была объявлена переменная с именем A . Она располагается по какому-то адресу в памяти. По этому адресу хранится значение 100.
Создали указатель типа int .
Теперь переменная p
хранит адрес переменной A
. Используя оператор * мы получаем доступ до содержимого переменной A
.
Чтобы изменить содержимое, пишем
После этого значение A
также изменено, так как она указывает на ту же область памяти. Ничего сложного.
Теперь другой важный пример
#include
Будет выведено
Несмотря на то, что переменные имеют разный тип и размер, указатели на них имеют один размер. Действительно, если указатели хранят адреса, то они должны быть целочисленного типа. Так и есть, указатель сам по себе хранится в переменной типа size_t
(а также ptrdiff_t
), это тип, который ведёт себя как целочисленный, однако его размер зависит от разрядности системы. В большинстве случаев разницы между ними нет. Зачем тогда указателю нужен тип?
Во-первых, указателю нужен тип для того, чтобы корректно работала операция разыменования (получения содержимого по адресу). Если указатель хранит адрес переменной, необходимо знать, сколько байт нужно взять, начиная от этого адреса, чтобы получить всю переменную.
Во-вторых, указатели поддерживают арифметические операции.
Для их выполнения необходимо знать размер.
операция сдвигает указатель вперёд на байт.
Например, если указатель int *p; хранит адрес CC02, то после p += 10; он будет хранить адрес СС02 + sizeof(int)*10 = CC02 + 28 = CC2A (Все операции выполняются в шестнадцатиричном формате). Пусть мы создали указатель на начало массива. После этого мы можем «двигаться» по этому массиву, получая доступ до отдельных элементов.
#include
Заметьте, каким образом мы получили адрес первого элемента массива
Массив, по сути, сам является указателем, поэтому не нужно использовать оператор &. Мы можем переписать пример по-другому
Получить адрес первого элемента и относительно него двигаться по массиву.
Кроме операторов + и — указатели поддерживают операции сравнения. Если у нас есть два указателя a и b, то a > b, если адрес, который хранит a, больше адреса, который хранит b.
#include
Если же указатели равны, то они указывают на одну и ту же область памяти.
Указатель хранит адрес области памяти. Можно создать указатель на указатель, тогда он будет хранить адрес указателя и сможет обращаться к его содержимому. Указатель на указатель определяется как
<тип> **<имя>;
Очевидно, ничто не мешает создать и указатель на указатель на указатель, и указатель на указатель на указатель на указатель и так далее. Это нам понадобится при работе с двумерными и многомерными массивами. А вот простой пример, как можно работать с указателем на указатель.
#include
Так как указатель хранит адрес, можно кастовать его до другого типа.
Это может понадобиться, например, если мы хотим взять часть переменной, или если мы знаем, что переменная хранит нужный нам тип.
#include
В этом примере мы пользуемся тем, что размер типа int равен 4 байта, а char 1 байт. За счёт этого, получив адрес первого байта, можно пройти по остальным байтам числа и вывести их содержимое.
Указатель до инициализации хранит мусор, как и любая другая переменная. Но в то же время, этот «мусор» вполне может оказаться валидным адресом. Пусть, к примеру, у нас есть указатель. Каким образом узнать, инициализирован он или нет? В общем случае никак. Для решения этой проблемы был введён макрос NULL библиотеки stdlib.
Принято при определении указателя, если он не инициализируется конкретным значением, делать его равным NULL.
int *ptr = NULL;
По стандарту гарантировано, что в этом случае указатель равен NULL
, и равен нулю, и может быть использован как булево значение false
. Хотя в зависимости от реализации NULL
может и не быть равным 0 (в смысле, не равен нулю в побитовом представлении, как например, int
или float
).
Это значит, что в данном случае
int *ptr = NULL; if (ptr == 0) { … }
вполне корректная операция, а в случае
int a = 0; if (a == NULL) { … }
поведение не определено. То есть указатель можно сравнивать с нулём, или с NULL , но нельзя NULL сравнивать с переменной целого типа или типа с плавающей точкой.
#include
Теперь несколько примеров работы с указателями
1. Пройдём по массиву и найдём все чётные элементы.
#include
2. Когда мы сортируем элементы часто приходится их перемещать. Если объект занимает много места, то операция обмена местами двух элементов будет дорогостоящей. Вместо этого можно создать массив указателей на исходные элементы и отсортировать его. Так как размер указателей меньше, чем размер элементов целевого массива, то и сортировка будет происходить быстрее. Кроме того, массив не будет изменён, часто это важно.
#include 3. Более интересный пример. Так как размер типа char всегда равен 1 байт, то с его помощью можно реализовать операцию swap – обмена местами содержимого двух переменных. #include В этом примере можно поменять тип переменных a
и b
на double
или любой другой (с соответствующим изменением вывода и вызова sizeof
), всё равно мы будет обменивать местами байты двух переменных. 4. Найдём длину строки, введённой пользователем, используя указатель #include Обратите внимание на участок кода while (*p != ‘\0’) { p++; length++; } его можно переписать while (*p != 0) { p++; length++; } или while (*p) { p++; length++; } или, убрав инкремент в условие while (*p++) { length++; } ru-Cyrl18-tutorialSypachev [email protected] Указатель
- это специальная переменная, которая хранит адрес другой переменной. Указатель объявляется следующим образом: тип* переменная;
где тип
- любой допустимый как простой, так и составной базовый тип указателя. Например, пусть объявлена обычная переменная int t;
Объявление и инициализация int* p= &t;
означают следующее. В переменной p
будетхраниться не обрабатываемое программой целое число (оценка студента, количество выпущенной продукции и т. п.), а адрес ячейки, в которой будет находиться информация указанного типа (целое число). Под адресом будем понимать номер первого байта выделенного для переменной участка оперативной памяти. Для переменных, не являющихся указателями, без дополнительного объявления адрес также запоминается системой, и его можно получить с помощью операции & (разадресации),
например, &t.
Эта унарная операция, которую иногда называют “взятие адреса”, ничего не делает со значением переменной t
. До первого использования переменная-указатель обязательно должна быть проинициализирована.
До тех пор, пока не определим значение указателя, он относится к чему-то случайному в памяти, и его использование может привести к непредсказуемым результатам. Один из способов показан выше и означает, что в переменную p
помещается адрес ячейки t
. Важно понять, что int* p= &t;
равносильно int* p; p=&t
; а не *p=&t
; В этом заключается одна из трудностей начального этапа изучения указателей. Эта тема усложняется ещё и тем, что такой же символ “&
” используется при объявлении переменной ссылочного типа. Здесь этот символ определяет операцию взятия адреса
для переменной и никакого отношения к ссылочному типу не имеет. Заметим, что расстановка пробелов при объявлении указателей свободная. Допустимы также следующие записи: int * p= & t; int *p= &t;
Предпочтение следовало бы отдать записи в начале параграфа, из которой легче понять смысл указателя. Объявляется переменная p
, а не *p
, и, кроме этого, типом является int*
, а не int
. Если одновременно объявляется несколько указателей, то символ “*” надо писать перед каждой переменной: float* q1, *q2;
Содержимое ячейки, адрес которой находится в p
, в тексте программы обозначается с помощью операции разыменование
. Для неё используется тот же символ “*”, что и при объявлении переменной-указателя. Эта унарная операция возвращает значение переменной, находящейся по указанному адресу. Поэтому *p
- это обрабатываемое программой целое число, находящееся в ячейке, адрес которой - в переменной-указателе p
. С учётом инициализации (p = &t
) *p
и t
- это одно и то же значение. Значит, если с помощью cin>>t;
введём, например, число 2 и выполним *p*=5
; или *p=*p*5;
то изменится и величина t
, хотя, казалось бы, не было явного её изменения. Поэтому оператор cout << t;
выведет число 10 (2*5). И наоборот, изменив t
(например, t++;
), этим самым мы изменим и значение *p.
С помощью cout<<(*p);
выведем 11. Сказанное выше будем обозначать так: p
(или &t
) *p
(или t
) В “левом прямоугольнике” (ячейке памяти) находится адрес, а в ячейке “справа” - обрабатываемое целое число. Рассматриваемые здесь операции “&” и ”*” являются унарными и имеют более высокий приоритет по сравнению с аналогичными бинарными операциями “битовое и” и арифметическое умножение. Для *p
определены те же операции, что и для переменной указанного типа, у нас - для целых чисел. Поэтому допустимы, например, следующие операторы: а) cin>>(*p);
b) int r; r=*p*2;
c) if (*p%2)…;
d) cout<<(*p);.
Можно выводить и значение переменной-указателя. cout< ⇐ Предыдущая567891011121314Следующая ⇒ Дата публикования: 2015-02-18; Прочитано: 526 | Нарушение авторского права страницы Studopedia.org — Студопедия.Орг — 2014-2018 год.(0.001 с)… — указатель на Работника. Вы можете назначить один выделенный объект этому указателю или, в вашем случае, несколько (с синтаксисом массива). Таким образом, он указывает на массив сотрудников. Вы разыменовали этот указатель. Поскольку он указывает на массив (нескольких) сотрудников, он также указывает на первую запись. Затем вы получаете доступ к целочисленной переменной-члену, которая по-прежнему возможна. Но затем вы пытаетесь использовать оператор индекса массива () для целочисленного значения, что невозможно. Вероятно, вы хотели получить доступ к переменной-члену -ой записи вашего выделенного массива. Поэтому вам нужно повернуть это: сначала используйте оператор индекса массива, затем обратитесь к члену этого конкретного сотрудника. в словах низкого уровня означает: возьмите указатель, добавьте раз размер указанного типа (чтобы он указывал на -ную запись) и разыменовал этот адрес, Это означает, что фактически является Employee в -ом индексе (но не в указателе). Затем вы хотите получить доступ к члену этого сотрудника. Если он все еще был указателем, вам нужно будет использовать оператор стрелки, но поскольку вы использовали оператор индекса массива (), вы уже разыменовали его, то оператор точки правильный: Указатель – переменная, значением которой является адрес ячейки памяти. То есть указатель ссылается на блок данных из области памяти, причём на самое его начало. Указатель может ссылаться на переменную или функцию. Для этого нужно знать адрес переменной или функции. Так вот, чтобы узнать адрес конкретной переменной в С++ существует унарная операция взятия адреса & . Такая операция извлекает адрес объявленных переменных, для того, чтобы его присвоить указателю. Указатели используются для передачи по ссылке данных, что намного ускоряет процесс обработки этих данных (в том случае, если объём данных большой), так как их не надо копировать, как при передаче по значению, то есть, используя имя переменной. В основном указатели используются для организации динамического распределения памяти, например при объявлении массива, не надо будет его ограничивать в размере. Ведь программист заранее не может знать, какого размера нужен массив тому или иному пользователю, в таком случае используется динамическое выделение памяти под массив. Любой указатель необходимо объявить перед использованием, как и любую переменную.
//объявление указателя
/*тип данных*/ * /*имя указателя*/;
Принцип объявления указателей такой же, как и принцип объявления переменных. Отличие заключается только в том, что перед именем ставится символ звёздочки * . Визуально указатели отличаются от переменных только одним символом. При объявлении указателей компилятор выделяет несколько байт памяти, в зависимости от типа данных отводимых для хранения некоторой информации в памяти. Чтобы получить значение, записанное в некоторой области, на которое ссылается указатель нужно воспользоваться операцией разыменования указателя * . Необходимо поставить звёздочку перед именем и получим доступ к значению указателя. Разработаем программу, которая будет использовать указатели. // 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. Написать свои версии функций преобразования строки в число и числа в строку. Память можно представить по-разному. Объяснение для военных на примере взвода. Есть взвод солдат. Численность - 30 человек. Построены в одну шеренгу. Если отдать им команду рассчитаться, у кажого в этой шеренге будет свой уникальный номер. Обязательно у каждого будет и обязательно уникальный. Этот взвод - доступная нам память. Всего нам здесь выделено для работы 30 ячеек. Можно использовать меньше. Больше - нельзя. К каждой ячейке можно обратиться и быть уверенным, что обратился именно к ней. Любому солдату можно дать что-то в руки. Например, цветы. То есть поместить по адресу данные. Объяснение для Маленького Принца. Здравствуй, Маленький Принц. Представим, что твоему барашку стало одиноко. И ты попросил нарисовать ему друзей. Ты выделил для барашков целую планету (точнее, астероид) по соседству. Эта планета - доступная память. Вся она уставлена коробочками, в которых будут жить барашки. Чтобы не запутаться, все коробочки пронумерованы. Коробочки - это ячейки памяти. Барашек в коробочке - это данные. Допустим, что попался какой-то особо упитанный барашек. Ему понадобится две коробочки. Или даже больше. Барашек - неделимая структура (для нас с тобой, Маленький Принц, это точно так), а коробочки идут подряд. Нет ничего проще. Мы вынимает стенки между двумя рядом стоящими коробочками и кладем туда барашка. Места в коробочке не очень много. И барашек не может свободно развернуться. Поэтому мы всегда знаем, где его голова, а где хвост. И если нам что-то нужно будет сказать барашку, мы обратимся к той коробочке, где у него голова. Объяснение для хулиганов. Есть забор. Забор из досок. Забор - доступная память. Доска - ячейка памяти. Забор длинный. И чтобы потом похвастаться друзьям, где ты сделал надпись, надо как-то обозначить место. Я знаю, о уважаемый хулиган, что ты нашел бы что-то поинтереснее, чем нумеровать каждую доску. Но в программировании не такие выдумщики. Поэтому доски просто пронумерованы. Возможно, твоя надпись поместится на одну доску. Например, %знак футбольного клуба%. Тогда ты просто скажешь номер и друзья увидят серьезность твоего отношения к футболу. А возможно, что одной доски не хватит. Ничего, главное, чтобы хватило забора. Пиши подряд. Просто потом скажи, с какой доски читать. А что если не подряд? Бывает и не подряд. Например, ты хочешь признаться Маше в любви. Ты назначаешь ей встречу под доской номер 40. Если все пройдет хорошо, ты возьмешь Машу и поведешь ее к доске 10, где заранее написал «Хулиган + Маша = любовь». Если что-то пошло не так, ты поведешь Машу к доске 60, на которой написано все нехорошее, что ты думаешь о Маше. Примерно так выглядит условный переход. То есть оба его исхода помещаются в память заранее. На каком-то этапе вычисляется условие. Если условие выполнилось - переходим к одному месту памяти и начинаем идти дальше подряд. Если условие не выполнилось - переходим к другому месту, с другими инструкциями. И тоже продолжаем выполнять их подряд. Инструкции всегда выполняются одна за другой, если только не встретился переход (с условием или без условия). Ну, или что-то поломалось. Модель взаимодействия программы с памятью компьютера может быть разной. Будем считать, что для каждой программы выделяется своя обособленная область памяти. Даже если запущены два экземпляра одной программы - память у них будет разная. В памяти хранятся числа. Ни с чем кроме чисел компьютер работать не умеет. Если вы поместили в память какую-то комплексную структуру, она все равно будет представлена числами. Даже если вы работаете с ней как со структурой. Примером комплексной структуры в терминах языков C и C++ может быть, например, экземпляр структуры или объект класса. Наименьшей адресуемой величиной в памяти типового компьютера является байт. Это означает, что каждый байт имеет собственный адрес. Для того, чтобы обратиться к полубайту, придется обратиться сначала к байту, а затем выделить из него половину. Возможно, подобные объяснения кажутся очевидными и даже смешными. Но в действительности имеет значение только формализация. И то, что кажется привычным, в определенных случаях может быть совсем иным. Например, запросто можно задать условие, при котором байт не будет равен 8 битам. И такие системы существуют. Раз уж мы договорились, что минимальная адресуемая величина - байт, то всю доступную программе память можно представить в виде последовательности байтов. Система в компьютере двоичная (хотя есть и тернарные машины). В 1 байте 8 бит. Английское bit означает binary digit, то есть двоичный разряд. Получается, что байт может принимать числовые значения от 0 до 2 в 8 степени без единицы. То есть от 0 до 255. Если представлять числа в шестнадцатеричной системе, то от 0x00 до 0xFF. Представим область памяти. В ней лежат числа от 1 до 16. Направление обхода обычно задается слева направо и сверху вниз. Помните, что никакой таблицы на самом деле нет (почти как ложки в Матрице). Она нужна человеку для удобства восприятия. Каждая такая ячейка описывается двумя величинами: значением и адресом. В приведенной таблице значение и адрес совпадают. Указатель - это переменная. Такая же, как и любая другая. Со своими «можно» и со своими «нельзя». У нее есть свое значение и свой адрес в памяти. Значение переменной-указателя - адрес другой переменной. Адрес переменной-указателя свой и независимый. Int *pointerToInteger;
Здесь объявляется переменная pointerToInteger. Ее тип - указатель на переменную типа int. Немного лирики. Как следует писать звездочку относительно типа и имени переменной? Встречаются, например, такие формы записи, и все они имеют право на существование: Int* p1;
int * p2;
int *p3;
Аргументы за первую форму. Чтобы объявить переменную следует указать ее тип, а затем имя. Звездочка является частью типа, а не частью имени. Это также подтверждается тем, что при привидении типов пишется тип со звездочкой, а не тип отдельно. Следовательно, должна писаться слитно с типом. Минус в том, что при объявлении нескольких переменных после объявления int*, только первая из них будет указателем, а вторая будет просто переменной типа int. Не объявляйте несколько указателей в одной строчке. Это не очень хороший стиль. Аргументы за вторую форму. Есть люди, которым нравится «когда код дышит» Они ставят пробел до скобок и после скобок. И здесь тоже ставят. Возможно, это просто такой компромисс. Аргументы за третью форму. Если писать так, то с объявлением нескольких указателей в одной строчке проблем быть не должно (хотя это все равно плохой тон). Некоторая идеология нарушается. Но этот стиль - самый распространенный, так как точно видно, что переменная - указатель. И помните, что компилятору все это безразлично. Рассмотрим две переменные: целочисленную переменную x и указатель на целочисленную переменную. Int x;
int *p;
Чтобы получить адрес переменной, нужно перед ее именем написать амперсанд. Данная конструкция будет выполняться справа налево. Сначала с помощью оператора &, примененного к переменной x, будет получен адрес x. Затем адрес x будет сохранен в указателе p. Есть и обратная операция. Чтобы получить значение переменной по ее адресу, следует написать звездочку перед именем указателя. Int y = *p;
Такая операция в русском языке называется не слишком благозвучным словом «разыменование». В английском - dereference. В данном примере с помощью оператора * мы получим то значение, которое находится в памяти по адресу p. Затем мы сохраним его в переменную y. В итоге получится, что значения x и y совпадают. Все это несложно увидеть на экране.
#include В указанном примере значение x и y будут одинаковы. А также адрес x и значение p. К указателям можно прибавлять числа. Из указателей можно вычитать числа. На основе этого сделана адресация в массиве. Этот код показывает несколько важных вещей. Int array = {1, 2, 3, 4, 5};
int *p = &array;
p++;
Первая строка простая и понятая. Объявлен массив и заполнен числами от 1 до 5. Во второй строке объявляется указатель на int и ему присваивается адрес нулевого элемента массива. Некоторые компиляторы разрешают писать такое присвоение так, считая, что имя массива означает адрес его нулевого элемента. Int *p = array;
Но если вы хотите избежать неоднозначности, пишите явно. Таким образом в p лежит адрес начала массива. А конструкция *p даст 1. Третья строчка увеличивает значение p. Но не просто на 1, а на 1 * sizeof(int). Пусть в данной системе int занимает 4 байта. После увеличения p на 1, p указывает не на следующий байт, а на первый байт из следующей четверки байтов. Программисту не нужно думать в данном случае о размере типа. С вычитанием ситуация такая же. Последний важный момент этого кода в том, как преобразуется обращение к элементу массива. Имя массива - это указатель на его начало. Точка отсчета. Индекс, переданный в квадратных скобках, - смещение относительно начала массива. Конструкция array[i] будет преобразована компилятором к *(array + i). К начальному адресу массива будет прибавлено число с учетом размерности типа данных. А затем будет взято значение по вычисленному адресу. Обратите внимание, что никто не запрещает написать и так i. Ведь конструкция будет преобразована к виду... С указателем можно складывать число, представленное переменной или целочисленной константой. Вычесть можно не только число, но и указатель из указателя. Это бывает полезно. А вот сложить два указателя, умножить или разделить указатель на число или на другой указатель - нельзя. С указателями разных типов нельзя обходиться легкомысленно. Char c;
char *pc = &c;
int *pi = pc;
С точки зрения языка C все корректно. А вот в C++ будет ошибка, потому что типы указателей не совпадают. Int *pi = (int*)pc;
Вот такая конструкция будет принята C++. Небольшое резюме. Int x; //объявление переменной целого типа
int *p; //объявление указателя на переменную целого типа
p = &x; //присвоить p адрес переменной x
x = *p; //присвоить x значение, которое находится по адресу, сохраненному в p
Обычно функция возвращает одно значение. А как вернуть больше одного? Рассмотрим код функции, которая меняет местами две переменные. Int swap(double a, double b) {
double temp = a;
a = b;
b = temp;
}
Пусть есть переменные x и y с некоторыми значениями. Если выполнить функцию, передав в нее x и y, окажется, что никакого обмена не произошло. И это правильно. При вызове этой функции в стеке будут сохранены значения x и y. Далее a и b получат значения x и y. Будет выполнена перестановка. Затем функция завершится и значения x и y будут восстановлены из стека. Все по-честному. Чтобы заставить функцию работать так, как нужно, следует передавать в нее не значения переменных x и y, а их адреса. Но и саму функцию тогда нужно адаптировать для работы с адресами. Void swap(double* a, double* b) {
double temp = *a;
*a = *b;
*b = temp;
}
Не стоить забывать о том, что и вызов функции теперь должен выглядеть иначе. Swap(&x, &y);
Теперь в функцию передаются адреса. И работа ведется относительно переданных адресов. Если функция должна вернуть несколько значений, необходимо передавать в нее адреса. Если функция должна менять значение переменной, нужно передавать ей адрес этой переменной. У тех, кто только начинает программировать на C, есть одна распространенная ошибка. При вводе с клавиатуры с помощью функции scanf() они передают значение переменной, а не ее адрес. А ведь scanf() должна менять значение переменной. Еще один важный случай, когда указатели крайне полезны - это передача большого объема данных. Немного посчитаем. Пусть нам нужно передать в функцию целое число типа int. Таким образом мы передаем в функцию sizeof(int) байт. Обычно это 4 байта (размер будет зависеть от архитектуры компьютера и компилятора). 4 байта - не так много. 4 байта уйдут в стек. Потому что имеет место передача по значению. Теперь нам нужно передать 10 таких переменных. Это уже 40 байт. Тоже невелика задача. Вообразим себя проектировщиками Большого Адронного Коллайдера. Вы отвечаете за безопасность системы. Именно вас окружают люди с недобрыми взглядами и факелами. Нужно показать им на модели, что конца света не будет. Для этого нужно передать в функцию collaiderModel(), скажем, 1 Гб данных. Представляете, сколько информации будет сохранено в стек? А скорее всего программа не даст вам стек такого объема без специальных манипуляций. Когда нужно передать большой объем данных, его передают не копированием, а по адресу. Все массивы, даже из одного элемента, передаются по адресу. Указатели - это мощный инструмент. Указатели эффективны и быстры, но не слишком безопасны. Потому как вся ответственность за их использования ложится на разработчика. Разработчик - человек. А человеку свойственно ошибаться. Представим ситуацию. Int x;
int *p;
В большинстве компиляторов C и С++ неинициализированные локальные переменные имеют случайное значение. Глобальные обнуляются. Если мы захотим разыменовать указатель и присвоить ему значение, скорее всего, будет ошибка.
*p = 10;
Неинициализированный указатель p хранит случайный адрес. Мы честно можем попытаться получить значение по этому адресу и что-то туда записать. Но совсем не факт, что нам можно что-то делать с памятью по этому адресу. Указатели можно и нужно обнулять. Для этого есть специальное значение NULL. Int *p = NULL;
Это запись больше соответствует стилю C. В C++ обычно можно инициализировать указатель нулем. Int *p = 0;
Ловкость рук и никакого мошенничества. На самом деле, если изучить библиотечные файлы языка, можно найти определение для NULL.
#define NULL (void*)0
Для C NULL - это нуль, приведенный к указателю на void. Для C++ все немного не так. Стандарт говорит: «The macro NULL is an implementation-defined C++ null pointer constant in this International Standard. Possible definitions include 0 and 0L, but not (void*)0». То есть это просто 0 или 0, приведенный к long. Предлагаю вам такую задачку. Папа Карло дал Буратино 5 яблок. Злой Карабас Барабас отобрал 3 яблока. Сколько яблок осталось у Буратино? Ответ: неизвестно. Так как нигде не сказано, сколько яблок у Буратино было изначально. Мораль: обнуляйте переменные. В языке C++ появился новый механизм работы с переменными - ссылки. Функция swap() была хороша, только не слишком удобно применять разыменование. С помощью ссылок функция swap() может выглядеть аккуратнее.
#include А вызов функции тогда будет уже без взятия адреса переменных. Swap(x, y);
Для взятия адреса переменной и для объявления ссылки используется одинаковый символ - амперсанд. Но в случае взятия адреса & стоит в выражении, перед именем переменной. А в случае объявления ссылки - в объявлении, после объявления типа. Использование ссылок и указателей - это очень широкая тема. Описание основ на этом закончим. За мысли и замечания спасибо Юрию Борисову, Указатель - переменная, содержащая адрес объекта. Указатель не несет информации о содержимом объекта, а содержит сведения о том, где размещен объект. Указатели похожи на метки, которые ссылаются на места в памяти. Они тоже имеют адрес, а их значение является адресом некоторой другой переменной. Переменная, объявленная как указатель, занимает 4 байта в оперативной памяти (в случае 32-битной версии компилятора). Тип указателя- это тип переменной, адрес которой он содержит. Для работы с указателями в Си определены две операции: Например: Сhar c; // переменная
char *p; // указатель
p = &c; // p = адрес c
Для того чтобы объявить указатель, который будет ссылаться на переменную, необходимо сначала получить адрес этой переменной. Чтобы получить адрес памяти переменной, нужно использовать знак «&» перед именем переменной. Это позволяет узнать адрес ячейки памяти, в которой хранится значение переменной. Эта операция называется - операция взятия адреса: Int var = 5; // простое объявление переменной с предварительной инициализацией
int *ptrVar; // объявили указатель, однако он пока ни на что не указывает
ptrVar = &var; // теперь наш указатель ссылается на адрес в памяти, где хранится число 5
Указатель хранит адрес области памяти. Можно создать указатель на указатель, тогда он будет хранить адрес указателя и сможет обращаться к его содержимому. Указатель на указатель определяется как:
<тип> **<имя>;
Пример работы указателя на указатель:
#include Так как указатель хранит адрес, можно кастовать его до другого типа. Это может понадобиться, если нужно взять часть переменной, или если мы знаем, что переменная хранит нужный нам тип. В следующем примере мы пользуемся тем, что размер типа int равен 4 байта, а char 1 байт. За счёт этого, получив адрес первого байта, можно пройти по остальным байтам числа и вывести их содержимое.
#include Указатель до инициализации хранит мусор, как и любая другая переменная. Но в, то, же время, этот “мусор” вполне может оказаться валидным адресом. Например, есть указатель. Каким образом узнать, инициализирован он или нет? В общем случае никак. Для решения этой проблемы был введён макрос NULL библиотеки stdlib. Принято при определении указателя, если он не инициализируется конкретным значением, делать его равным NULL. Int *ptr = NULL;
По стандарту гарантировано, что в этом случае указатель равен NULL, и равен нулю, и может быть использован как булево значение false. Хотя в зависимости от реализации NULL может и не быть равным 0. То есть указатель можно сравнивать с нулём, или с NULL, но нельзя NULL сравнивать с переменной целого типа или типа с плавающей точкой.Указатели в Си.
Обозначения и предположения
Указатели на указатели
Указатели на функции
Указатели и строки языка Си
Примеры на работу со строками и указателями
Работа с динамической памятью
Немного о памяти
0x01
0x02
0x03
0x04
0x05
0x06
0x07
0x08
0x09
0x0A
0x0B
0x0C
0x0D
0x0E
0x0F
0x10
Понятие указателя
Адрес переменной и значение переменной по адресу
Адресная арифметика
Применение указателей
Ссылки
Синтаксис указателей
тип *ИмяОбъекта;
Объявление указателя, получение адреса переменной
Указатель на указатель
Указатели и приведение типов
NULL pointer – нулевой указатель
