Последнее обновление: 27.05.2017
Указатели в языке Си поддерживают ряд операций: присваивание, получение адреса указателя, получение значения по указателю, некоторые арифметические операции и операции сравнения.
Присваивание
Указателю можно присвоить либо адрес объекта того же типа, либо значение другого указателя или константу NULL .
Присвоение указателю адреса уже рассматривалось в прошлой теме. Для получения адреса объекта используется операция & :
Int a = 10; int *pa = &a; // указатель pa хранит адрес переменной a
Причем указатель и переменная должны иметь тот же тип, в данном случае int.
Присвоение указателю другого указателя:
#include
Когда указателю присваивается другой указатель, то фактически первый указатель начинает также указывать на тот же адрес, на который указывает второй указатель.
Если мы не хотим, чтобы указатель указывал на какой-то конкретный адрес, то можно присвоить ему условное нулевое значение с помощью константы NULL , которая определена в заголовочном файле stdio.h:
Int *pa = NULL;
Разыменование указателя
Операция разыменования указателя в виде *имя_указателя, позволяет получить объект по адресу, который хранится в указателе.
#include
Через выражение *pa мы можем получить значение по адресу, который хранится в указателе pa , а через выражение типа *pa = значение вложить по этому адресу новое значение.
И так как в данном случае указатель pa указывает на переменную a , то при изменении значения по адресу, на который указывает указатель, также изменится и значение переменной a .
Адрес указателя
Указатель хранит адрес переменной, и по этому адресу мы можем получить значение этой переменной. Но кроме того, указатель, как и любая переменная, сам имеет адрес, по которому он располагается в памяти. Этот адрес можно получить также через операцию & :
Int a = 10; int *pa = &a; printf("address of pointer=%p \n", &pa); // адрес указателя printf("address stored in pointer=%p \n", pa); // адрес, который хранится в указателе - адрес переменной a printf("value on pointer=%d \n", *pa); // значение по адресу в указателе - значение переменной a
Операции сравнения
К указателям могут применяться операции сравнения > , >= , < , <= ,== , != . Операции сравнения применяются только к указателям одного типа и константе NULL . Для сравнения используются номера адресов:
Int a = 10; int b = 20; int *pa = &a; int *pb = &b; if(pa > pb) printf("pa (%p) is greater than pb (%p) \n", pa, pb); else printf("pa (%p) is less or equal pb (%p) \n", pa, pb);
Консольный вывод в моем случае:
Pa (0060FEA4) is greater than pb (0060FEA0)
Приведение типов
Иногда требуется присвоить указателю одного типа значение указателя другого типа. В этом случае следует выполнить операцию приведения типов:
Char c = "N"; char *pc = &c; int *pd = (int *)pc; printf("pc=%p \n", pc); printf("pd=%p \n", pd);
Теги: Си указатели. Указатель на указатель. Тип указателя. Арифметика указателей. Сравнение указателей.
Указатели
Э то, пожалуй, самая сложная и самая важная тема во всём курсе. Без понимания указателей дальнейшее изучении си будет бессмысленным. Указатели – очень простая концепция, очень логичная, но требующая внимания к деталям.
Определение
У казатель – это переменная, которая хранит адрес области памяти. Указатель, как и переменная, имеет тип. Синтаксис объявления указателей
<тип> *<имя>;
Например
float *a;
long long *b;
Два основных оператора для работы с указателями – это оператор & взятия адреса, и оператор * разыменования. Рассмотрим простой пример.
#include
Рассмотрим код внимательно, ещё раз
Int A = 100;
Была объявлена переменная с именем A . Она располагается по какому-то адресу в памяти. По этому адресу хранится значение 100.
Создали указатель типа int .
Теперь переменная p
хранит адрес переменной A
. Используя оператор * мы получаем доступ до содержимого переменной A
.
Чтобы изменить содержимое, пишем
*p = 200;
После этого значение A
также изменено, так как она указывает на ту же область памяти.
Ничего сложного.
Теперь другой важный пример
#include
Будет выведено
4
4
8
4
Несмотря на то, что переменные имеют разный тип и размер, указатели на них имеют один размер. Действительно, если указатели хранят адреса, то они
должны быть целочисленного типа. Так и есть, указатель сам по себе хранится в переменной типа size_t
(а также ptrdiff_t
),
это тип, который ведёт себя как целочисленный, однако его размер зависит от разрядности системы. В большинстве
случаев разницы между ними нет. Зачем тогда указателю нужен тип?
Арифметика указателей
В
о-первых, указателю нужен тип для того, чтобы корректно работала операция разыменования (получения содержимого по адресу).
Если указатель хранит адрес переменной, необходимо знать, сколько байт нужно взять, начиная от этого адреса, чтобы получить всю переменную.
Во-вторых, указатели поддерживают арифметические операции. Для их выполнения необходимо знать размер.
операция + N сдвигает указатель вперёд на N*sizeof(тип) байт.
Например, если указатель
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 pointer - нулевой указатель
У
казатель до инициализации хранит мусор, как и любая другая переменная. Но в то же время, этот "мусор" вполне может оказаться валидным адресом. Пусть, к примеру, у нас есть указатель. Каким образом узнать, инициализирован он или нет? В общем случае никак.
Для решения этой проблемы был введён макрос 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 – обмена местами содержимого двух переменных. Пожалуйста, приостановите работу 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; // получаем адрес переменной 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; часть функции после заголовка, заключенная в фигурные скобки { называют телом функции. Итак, когда мы работаем с функцией надо указать имя функции, у нас это 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 Будет выведено Во-первых, указателю нужен тип для того, чтобы корректно работала операция разыменования (получения содержимого по адресу). Если указатель хранит адрес переменной, необходимо знать, сколько байт нужно взять, начиная от этого адреса, чтобы получить всю переменную. Для их выполнения необходимо знать размер. #include Заметьте, каким образом мы получили адрес первого элемента массива Массив, по сути, сам является указателем, поэтому не нужно использовать оператор &. Мы можем переписать пример по-другому Получить адрес первого элемента и относительно него двигаться по массиву. #include Если же указатели равны, то они указывают на одну и ту же область памяти. Указатель хранит адрес области памяти. Можно создать указатель на указатель, тогда он будет хранить адрес указателя и сможет обращаться к его содержимому. Указатель на указатель определяется как <тип> **<имя>; Очевидно, ничто не мешает создать и указатель на указатель на указатель, и указатель на указатель на указатель на указатель и так далее. Это нам понадобится при работе с двумерными и многомерными массивами. А вот простой пример, как можно работать с указателем на указатель. #include Так как указатель хранит адрес, можно кастовать его до другого типа. Это может понадобиться, например, если мы хотим взять часть переменной, или если мы знаем, что переменная хранит нужный нам тип. #include В этом примере мы пользуемся тем, что размер типа int
равен 4 байта, а char
1 байт. За счёт этого, получив адрес первого байта, можно пройти по остальным байтам числа и вывести их содержимое. Указатель до инициализации хранит мусор, как и любая другая переменная. Но в то же время, этот «мусор» вполне может оказаться валидным адресом. Пусть, к примеру, у нас есть указатель. Каким образом узнать, инициализирован он или нет? В общем случае никак. Для решения этой проблемы был введён макрос NULL библиотеки stdlib. int *ptr = NULL; По стандарту гарантировано, что в этом случае указатель равен NULL
, и равен нулю, и может быть использован как булево значение false
. Хотя в зависимости от реализации NULL
может и не быть равным 0 (в смысле, не равен нулю в побитовом представлении, как например, int
или float
). int *ptr = NULL; if (ptr == 0) { … } вполне корректная операция, а в случае int a = 0; if (a == NULL) { … } поведение не определено. То есть указатель можно сравнивать с нулём, или с NULL
, но нельзя NULL
сравнивать с переменной целого типа или типа с плавающей точкой. #include Теперь несколько примеров работы с указателями #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 в -ом индексе (но не в указателе). Затем вы хотите получить доступ к члену этого сотрудника. Если он все еще был указателем, вам нужно будет использовать оператор стрелки, но поскольку вы использовали оператор индекса массива (), вы уже разыменовали его, то оператор точки правильный: Последнее обновление: 27.05.2017 Указатели представляют собой объекты, значением которых служат адреса других объектов (переменных, констант, указателей) или функций. Указатели - это неотъемлемый компонент для управления памятью в языке Си. Для определения указателя надо указать тип объекта, на который указывает указатель, и символ звездочки *. Например, определим указатель на
объект типа int: Пока указатель не ссылается ни на какой объект. Теперь присвоим ему адрес переменной: Int x = 10; // определяем переменную
int *p; // определяем указатель
p = &x; // указатель получает адрес переменной
Указатель хранит адрес объекта в памяти компьютера. И для получения адреса к переменной применяется операция &
.
Эта операция применяется только к таким объектам, которые хранятся в памяти компьютера, то есть к переменным и элементам массива. Что важно, переменная x имеет тип int, и указатель, который указывает на ее адрес тоже имеет тип int. То есть должно быть соответствие по типу. Какой именно адрес имеет переменная x? Для вывода значения указателя можно использовать специальный спецификатор %p
:
#include В моем случае машинный адрес переменной x - 0060FEA8. Но в каждом отдельном случае адрес может быть иным. Фактически адрес представляет целочисленное значение, выраженное в шестнадцатеричном формате. То есть в памяти компьютера есть адрес 0x0060FEA8, по которому располагается переменная x. Так как переменная x представляет тип int
,
то на большинстве архитектур она будет занимать следующие 4 байта (на конкретных архитектурах размер памяти для типа int может отличаться). Таким образом,
переменная типа int последовательно займет ячейки памяти с адресами 0x0060FEA8, 0x0060FEA9, 0x0060FEAA, 0x0060FEAB. И указатель p
будет ссылаться на адрес, по которому располагается переменная x, то есть на адрес 0x0060FEA8. Но так как указатель хранит адрес, то мы можем по этому адресу получить хранящееся там значение, то есть значение переменной x. Для этого применяется
операция *
или операция разыменования, то есть та операция, которая применяется при определении указателя. Результатом этой
операции всегда является объект, на который указывает указатель. Применим данную операцию и получим значение переменной x:
#include Консольный вывод: Address = 0060FEA8
x = 10 Используя полученное значение в результате операции разыменования мы можем присвоить его другой переменной: Int x = 10;
int *p = &x;
int y = *p;
printf("x = %d \n", y); // 10
И также используя указатель, мы можем менять значение по адресу, который хранится в указателе: Int x = 10;
int *p = &x;
*p = 45;
printf("x = %d \n", x); // 45
Так как по адресу, на который указывает указатель, располагается переменная x, то соответственно ее значение изменится. Создадим еще несколько указателей:
#include В моем случае я получу следующий консольный вывод: Variable c: address=0060FEA3 value=N
Variable d: address=0060FE9C value=10
Variable s: address=0060FE9A value=2 По адресам можно увидеть, что переменные часто расположены в памяти рядом, но не обязательно в том порядке, в котором они определены в тексте программы. Память можно представить по-разному. Объяснение для военных на примере взвода. Есть взвод солдат. Численность - 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);
Для взятия адреса переменной и для объявления ссылки используется одинаковый символ - амперсанд. Но в случае взятия адреса & стоит в выражении, перед именем переменной. А в случае объявления ссылки - в объявлении, после объявления типа. Использование ссылок и указателей - это очень широкая тема. Описание основ на этом закончим. За мысли и замечания спасибо Юрию Борисову,
Функции в Си
Для чего нужны функции в C?
Простой пример функции в Cи
puts(«Functions in C»);
return EXIT_SUCCESS;
}Как из одной функции в Cи вызвать другую функцию?
Прототип функции в Си
Чем объявление функции в Си отличается от определения функции в Си?
Оператор return
Указатели в языке Си
Передача аргументов функции по значению
Передача указателей функции Си
C/C++ в Eclipse
Указатели
Определение
Тема 7. Указатели в Си.
Два основных оператора для работы с указателями – это оператор & взятия адреса, и оператор * разыменования. Рассмотрим простой пример.
Чтобы изменить содержимое, пишем
Теперь другой важный пример
Несмотря на то, что переменные имеют разный тип и размер, указатели на них имеют один размер. Действительно, если указатели хранят адреса, то они должны быть целочисленного типа. Так и есть, указатель сам по себе хранится в переменной типа size_t
(а также ptrdiff_t
), это тип, который ведёт себя как целочисленный, однако его размер зависит от разрядности системы. В большинстве случаев разницы между ними нет. Зачем тогда указателю нужен тип?Арифметика указателей
Во-вторых, указатели поддерживают арифметические операции.
операция сдвигает указатель вперёд на байт.
Например, если указатель int *p; хранит адрес CC02, то после p += 10; он будет хранить адрес СС02 + sizeof(int)*10 = CC02 + 28 = CC2A (Все операции выполняются в шестнадцатиричном формате). Пусть мы создали указатель на начало массива. После этого мы можем «двигаться» по этому массиву, получая доступ до отдельных элементов.
Кроме операторов + и — указатели поддерживают операции сравнения. Если у нас есть два указателя a и b, то a > b, если адрес, который хранит a, больше адреса, который хранит b.Указатель на указатель
Указатели и приведение типов
NULL pointer — нулевой указатель
Принято при определении указателя, если он не инициализируется конкретным значением, делать его равным NULL.
Это значит, что в данном случаеПримеры
1. Пройдём по массиву и найдём все чётные элементы.Указатели в Си.
Обозначения и предположения
Немного о памяти
0x01
0x02
0x03
0x04
0x05
0x06
0x07
0x08
0x09
0x0A
0x0B
0x0C
0x0D
0x0E
0x0F
0x10
Понятие указателя
Адрес переменной и значение переменной по адресу
Адресная арифметика
Применение указателей
Ссылки