Объявление и инициализация переменной-указателя. Указатели представляют собой переменные, значениями которых являются адреса памяти. Указатель содержит адрес переменной, в которой находится конкретное значение. Переменная непосредственно ссылается на значение, а указатель косвенно ссылается на значение. Ссылка на значение через посредство указателя называется косвенной адресацией.
Указатели, как и любые другие переменные, должны быть объявлены, прежде чем они будут использоваться. В операторе
int *countPtr, count;
объявляется переменная countPtrтипаint* (указатель на целочисленное значение). Символ * в объявлении распространяется только наcountPtr. Этот символ означает, что объявляемая переменная является указателем. Можно объявлять указатели, ссылающиеся на объекты любого типа.
Указатели должны быть инициализированы либо при объявлении, либо при помощи оператора присваивания. Указатель может быть инициализирован нулем, макросом NULLили значением адреса. Указатель со значениемNULLне указывает ни на что. Инициализация указателя значением 0 эквивалента инициализации указателя константойNULL, однако использованиеNULLпредпочтительнее. Когда присваивается значение 0, то происходит его преобразование к указателю соответствующего типа. Значение 0 является единственным целым числом, которой может быть присвоено переменной-указателю непосредственно.
Операции с указателями. Язык Си предлагает 5 основных операций, которые можно применить к указателям.
Присваивание. Указателю можно присвоить адрес. Обычно выполняется это действие, используя имя массива или оператор получения адреса (&).
Определения значения. Операция (*) выдает значение, хранящееся в указанной ячейке.
Получение адреса указателя. Подобно любым переменным переменная типа указатель имеет адрес и значение. Операция & сообщает, где находится сам указатель.
Увеличение указателя. Это действие выполняется с помощью обычной операции сложения либо с помощью операции увеличения. Увеличивая указатель, мы перемещаем его на следующий элемент массива.
5. Разность. Можно найти разность двух указателей. Обычно это делается для указателей, ссылающихся на элементы одного и того же массива; чтобы определить, на каком расстоянии друг от друга находятся элементы. Результат имеет тот же тип, что и переменная, содержащая размер массива.
К указателям можно применить арифметические операции, такие как: ++, --, +, +=, -, -= и можно вычислить разность двух указателей.
В качестве примера определим массив int v, первый элемент которого будет иметь адрес в памяти, равный 3000. Инициализируем указатель vPtr значением адреса v, т.е. значение vPtr равно 3000, любым из следующих операторов
При прибавлении или вычитании из указателя целого числа значение его увеличивается или уменьшается не на это число, а на произведение числа на размер объекта, на который указатель ссылается.
Размер объекта в байтах зависит от типа объекта. Например, оператор
даст результат 3008 (3000+2*4), если для целого числа отводится в памяти 4 байта. Теперь vPtr будет ссылаться на элемент v.
Если бы vPtr был увеличен до значения 3016, которое соответствует адресу элемента массива v, то оператор
вернул бы vPtr к значению 3000, соответствующему началу массива. При увеличении или уменьшении указателя на единицу можно использовать операции инкремента (++) и декремента (--). Каждый из следующих операторов
увеличивает значение указателя, который будет ссылаться на следующий элемент массива. Любой из следующих операторов
уменьшает значение указателя, который получает при этом доступ к предыдущему элементу массива.
x = v2Ptr - vPtr;
переменной х будет присвоено число элементов массива, расположенных начиная с адреса vPtrи доv2Ptr; в данном случае это будет значение 2.
Указатель может быть присвоен другому указателю, если оба указателя имеют один и тот же тип. В противном случае надо использовать операцию приведения типа указателя в правой части оператора присваивания к типу указателя в левой части.
Передача параметра по ссылке. В Си для организации вызова по ссылке используются указатели и операция косвенной адресации. Если вызывается функция, аргументы которой должны изменяться, то в этом случае ей передаются адреса аргументов. Обычно для этой цели применяется операция взятия адреса (&) к переменной, значение которой будет изменяться. Когда адрес переменной передан функции, то для изменения ее значения может быть использована операция косвенной адресации (*). В следующей программе приведено использование передачи параметра по ссылке.
#include
{ int x=5, y=10;
printf(“x=%d y=%d\n”, x, y);
change(&x,&y); /* передача адресов функции */
printf(“x=%d y=%d\n”, x, y); }
change (int *u, int *v)
temp=*u; /*tempприсваивается значение, на которое указываетu*/
Результат программы:
Данная функция изменяет значения переменных xиy. Путем передачи функции адресов переменных х и у мы предоставили ей возможность доступа к ним. Используя указатели и операцию (*), функция смогла извлечь величины, помещенные в соответствующие ячейки памяти, и менять их местами.
Основная ли тература: 1осн,2осн
Дополнительная литератур а: 9доп
Контрольные вопросы:
1. Назовите операции для работы с указателями?
2. На какое число увеличивается значение указателя при прибавлении из указателя целого числа?
3. Приведите пример инициализации переменной-указателя?
4. Приведите пример объявления переменной-указателя?
5. Какая операция используется для организации вызова по ссылке?
Последнее обновление: 27.05.2017
Указатели в языке Си поддерживают ряд операций: присваивание, получение адреса указателя, получение значения по указателю, некоторые арифметические операции и операции сравнения.
Присваивание
Указателю можно присвоить либо адрес объекта того же типа, либо значение другого указателя или константу 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);
Указатель - переменная, содержащая адрес объекта. Указатель не несет информации о содержимом объекта, а содержит сведения о том, где размещен объект.
Указатели похожи на метки, которые ссылаются на места в памяти. Они тоже имеют адрес, а их значение является адресом некоторой другой переменной. Переменная, объявленная как указатель, занимает 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 pointer – нулевой указатель
Указатель до инициализации хранит мусор, как и любая другая переменная. Но в, то, же время, этот “мусор” вполне может оказаться валидным адресом. Например, есть указатель. Каким образом узнать, инициализирован он или нет? В общем случае никак. Для решения этой проблемы был введён макрос NULL библиотеки stdlib.
Принято при определении указателя, если он не инициализируется конкретным значением, делать его равным NULL.
Int *ptr = NULL;
По стандарту гарантировано, что в этом случае указатель равен NULL, и равен нулю, и может быть использован как булево значение false. Хотя в зависимости от реализации NULL может и не быть равным 0. То есть указатель можно сравнивать с нулём, или с NULL, но нельзя NULL сравнивать с переменной целого типа или типа с плавающей точкой.
Пожалуйста, приостановите работу 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?
Функции в Си применяются для выполнения определённых действий в рамках общей программы. Программист сам решает какие именно действия вывести в функции. Особенно удобно применять функции для многократно повторяющихся действий.
Простой пример функции в Cи
Пример функции в 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.
Как из одной функции в 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
Оператор 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, чего не наблюдалось в предыдущм пункте, когда мы передавали аргумент по значению.
C/C++ в Eclipse
Все примеры для этой статьи я сделал в Eclipse. Как работать с C/C++ в Eclipse можно посмотреть здесь. Если вы работаете в другой среде, то примеры и там будут работать.
Теги: Си указатели. Указатель на указатель. Тип указателя. Арифметика указателей. Сравнение указателей.
Указатели
Это, пожалуй, самая сложная и самая важная тема во всём курсе. Без понимания указателей дальнейшее изучении си будет бессмысленным. Указатели – очень простая концепция, очень логичная, но требующая внимания к деталям.
Определение
Указатель – это переменная, которая хранит адрес области памяти.
Тема 7. Указатели в Си.
Указатель, как и переменная, имеет тип. Синтаксис объявления указателей
<тип> *<имя>;
Например
Два основных оператора для работы с указателями – это оператор & взятия адреса, и оператор * разыменования. Рассмотрим простой пример.
#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 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 – обмена местами содержимого двух переменных. #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 в -ом индексе (но не в указателе). Затем вы хотите получить доступ к члену этого сотрудника. Если он все еще был указателем, вам нужно будет использовать оператор стрелки, но поскольку вы использовали оператор индекса массива (), вы уже разыменовали его, то оператор точки правильный: Хотелось бы с самого начала прояснить одну вещь - я не отношу себя к категории true-кодеров, сам учусь по специальности, не связанной с разработкой ПО, и это мой первый пост. Прошу судить по всей
строгости. Итак, в свое время то ли по причине того, что я спал на лекциях, то ли я не особо вникал в эту тему, но у меня возникали некоторые сложности при работе с указателями в плюсах. Теперь же ни одна моя даже самая крохотная быдлокодерская программа не обходится без указателей. В данной статье я попытаюсь рассказать базовые вещи: что такое указатели, как с ними работать и где их можно применять. Повторюсь, изложенный ниже материал предназначен для новичков. Void main(){
int i_val = 7;
}
Мы объявили переменную типа int
и здесь же ее проинициализировали. Что же произойдет при компиляции программы? В оперативной памяти, в куче, будет выделено свободное место такого размера, что там можно будет беспрепятственно разместить значение нашей переменной i_val
. Переменная займет некоторый участок памяти, разместившись в нескольких ячейках в зависимости от своего типа; учитывая, что каждая такая ячейка имеет адрес, мы можем узнать диапазон адресов, в пределах которого разместилось значение переменной. В данном случае, при работе с указателями нам нужен лишь один адрес - адрес первой ячейки, именно он и послужит значением, которым мы проинициализируем указатель. Итак: Void main(){
// 1
int i_val = 7;
int* i_ptr = &i_val;
// 2
void* v_ptr = (int *)&i_val
}
#include (*i_ptr)++; // результат эквивалентен операции инкремента самой переменной: i_val++
// т.е. в данном случае в i_val сейчас хранится значение не 7, а 8.
Void main(){
const int size = 7;
// объявление
int i_array;
// инициализация элементов массива
for (int i = 0; i != size; i++){
i_array[i] = i;
}
}
Int* arr_ptr = i_array;
for (int i = 0; i != size; i++){
cout << *(arr_ptr + i) << endl;
}
*(arr_ptr + 0)
это тот же самый нулевой элемент, смещение нулевое (i
= 0), Однако, здесь возникает естественный вопрос - почему присваивая указателю адрес начала массива, мы не используем операцию взятия адреса? Ответ прост - использование идентификатора массива без указания квадратных скобок эквивалентно указанию адреса его первого элемента. Тот же самый пример, только в указатель «явно» занесем адрес первого элемента массива: Int* arr_ptr_null = &i_array;
for (int i = 0; i != size; i++){
cout << *(arr_ptr_null + i) << endl;
}
Пройдем по элементам с конца массива: Int size = -1;
// здесь происходят какие - то
// действия, которые изменяют
// значение переменной size
int* dyn_arr = new int;
Что такое указатель на указатель? Это та же переменная, которая хранит адрес другого указателя „более низкого порядка“. Зачем он нужен? Для инициализации двумерного динамического массива, например: Const int size = 7;
// двумерный массив размером 7x7
int** i_arr = new int*;
for(int i = 0; i != size; i++){
i_arr[i] = new int;
}
Class MyClass{
public:
int a;
public:
MyClass(int v){ this->a = v; };
~MyClass(){};
};
void main(){
MyClass*** v = new MyClass**;
for (int i = 0; i != 7; i++){
v[i] = new MyClass*;
for (int j = 0; j != 3; j++){
v[i][j] = new MyClass(i*j);
}
}
}
Здесь два указателя нужны для формирования матрицы, в которой будут располагаться объекты, третий - собственно для размещения там динамических объектов (не MyClass a
, а MyClass* a
). Это не единственный пример использования указателей такого рода, чуть ниже будут рассмотрены еще примеры. Void f1(int**, int);
void main(){
const int size = 4;
// объявление и выделение памяти
// под другие указатели
int** a = new int*;
int** b = new int*;
// выделение памяти под числовые значения
for (int i = 0; i != size; i++){
a[i] = new int;
b[i] = new int;
// собственно инициализация
for (int j = 0; j != size; j++){
a[i][j] = i * j + 1;
b[i][j] = i * j - 1;
}
}
}
void f1(int** a, int c){
for (int i = 0; i != c; i++){
for (int j = 0; j != c; j++){
cout.width(3);
cout << a[i][j];
}
cout << endl;
}
cout << endl;
}
Задача
: заменить значения элементов массива a
соответствующими элементами из массива b
, учитывая, что это должно произойти в некоторой функции, которая так или иначе занимается обработкой массивов. Цель: разобраться в способе передачи указателей для их дальнейшей модификации. Void f2(int** a, int** b, int c){
for (int i = 0; i != c; i++){
for (int j = 0; j != c; j++){
a[i][j] = b[i][j];
}
}
}
После вызова данной функции в теле main
- f2(a, b, 4)
содержимое массивов a и b станет одинаковым. Void main(){
const int size = 4;
// объявление и выделение памяти
// под другие указатели
int** a = new int*;
int** b = new int*;
// выделение памяти под числовые значения
for (int i = 0; i != size; i++){
a[i] = new int;
b[i] = new int;
// собственно инициализация
for (int j = 0; j != size; j++){
a[i][j] = i * j + 1;
b[i][j] = i * j - 1;
}
}
// Здесь это сработает
a = b;
}
Void f3(int** a, int** b){
a = b;
}
Сработает ли она? Если мы внутри функции f3
вызовем функцию f1(a, 4)
, то увидим, что значения массива действительно поменялись. НО: если мы посмотрим содержимое массива a
в main - то обнаружим обратное - ничего не изменилось. Так в чем же причина? Все предельно просто: в функции f3
мы работали не с самим указателем a
, а с его локальной копией! Все изменения, которые произошли в функции f3
- затронули только локальную копию указателя, но никак не сам указатель a
. Давайте посмотрим на следующий пример: Void false_eqv(int, int);
void main(){
int a = 3, b = 5;
false_eqv(a, b);
// Поменялось значение a?
// Конечно же, нет
}
false_eqv(int a, int b){
a = b;
}
Итак, я думаю, вы поняли, к чему я веду. Переменной a
нельзя присвоить таким образом значение переменной b
- ведь мы передавали их значения напрямую, а не по ссылке. То же самое и с указателями - используя их в качестве аргументов таким образом, мы заведомо лишаем их возможности изменения значения. Void f4(int***, int**);
void main(){
const int size = 4;
int** a = new int*;
int** b = new int*;
for (int i = 0; i != 4; i++){
a[i] = new int;
b[i] = new int;
for (int j = 0; j != 4; j++){
a[i][j] = i * j + 1;
b[i][j] = i * j - 1;
}
}
int*** d = &a;
f4(d, b);
}
void f4(int*** a, int** b){
*a = b;
}
Кстати, а чего это мы создаем динамические объекты? Ну ладно размер массива не знали, а экземпляры классов мы зачем динамическими делали? Да потому что зачастую, созданный нами объекты свое - они генерились, порождали новые данные/объекты для дальнейшей работы, а теперь пришло им время... умереть [фу, как грубо]
уйти со сцены. И как мы это сделаем? Просто: Delete(a);
delete(b);
// Вот и кончились наши двумерные массивы
delete(v);
// Вот и нет больше двумерного массива с динамическими объектами
delete(dyn_array);
// Вот и удалился одномерный массив
На данной ноте я хотел бы закончить свое повествование. Если найдется хотя бы пара ребят, которым понравится стиль изложения материала, то я постараюсь продолжить… ой, да кого я обманываю, мне нужен инвайт и все на этом, дайте инвайт и вашим глазам больше не придется видеть это околесицу. Шучу, конечно. Ругайте, комментируйте.
Указатели в Си.
Обозначения и предположения
/* Ребят, в статье было найдено много ошибок. Спасибо тем людям, которые внесли свои замечания. В связи с этим - после прочтения статьи обязательно перечитайте комментарии */1. Общие сведения
Итак, что же такое указатель? Указатель - это та же переменная, только инициализируется она не значением одного из множества типов данных в C++, а адресом, адресом некоторой переменной, которая была объявлена в коде ранее. Разберем на примере:
# Здесь ниже, конечно, я ребятки вам соврал. Переменная i_val - статическая, она явно будет размещена в стеке. В куче место выделяется под динамические объекты. Это важные вещи! Но в данном контексте, я, сделав сам себе замечание, позволю оставить себе все как есть, так что сильно не ругайтесь.
Используя унарную операцию взятия адреса &
, мы извлекаем адрес переменной i_val
и присваиваем ее указателю. Здесь стоит обратить внимание на следующие вещи:
Теперь, когда мы имеем указатель на переменную i_va
l мы можем оперировать ее значением не только непосредственно с помощью самой переменной, но и с помощью указателя на нее. Посмотрим, как это работает на простом примере:
В предыдущем примере был организован только вывод значения переменной на экран. Можем ли мы непосредственно через указатель оперировать с значением переменной, на которую он указывает? Да, конечно, для этого они и реализованы (однако, не только для этого - но об этом чуть позже). Все, что нужно - сделать разыменование указателя: 2. Массивы
Сразу перейдем к примеру - рассмотрим статичный одномерный массив определенной длинны и инициализируем его элементы:
А теперь будем обращаться к элементам массива, используя указатели:
Что здесь происходит: мы инициализируем указатель arr_ptr
адресом начала массива i_array
. Затем, в цикле мы выводим элементы, обращаясь к каждому с помощью начального адреса и смещения. То есть:
*(arr_ptr + 1)
- первый (i
= 1), и так далее.
int* arr_ptr_end = &i_array;
for (int i = 0; i != size; i++){
cout << *(arr_ptr_end - i) << endl;
}
Замечания:3. Динамическое выделение памяти
Вот та замечательная плюшка, из-за которой я использую указатели. Начнем с динамических массивов. Зачастую при решении какой-либо задачи возникает потребность в использовании массива неопределенного размера, то есть размер этот заранее неизвестен. Здесь нам на помощь приходят динамические массивы - память под них выделяется в процессе выполнения программы. Пример:
Что здесь происходит: мы объявляем указатель и инициализируем его началом массива, под который выделяется память оператором new
на size
элементов. Следует заметить, что в этом случае мы можем использовать те же приемы в работе с указателями, что и с статическим массивом. Что следует из этого извлечь - если вам нужна какая - то структура (как массив, например), но ее размер вам заранее неизвестен, то просто сделайте объявление этой структуры, а проинициализируете ее уж позже. Более полный пример приведу чуть позже, а пока что - рассмотрим двойные указатели.
А тройной указатель? Трехмерный динамический массив. Неинтересно, скажите вы, так можно продолжать до бесконечности. Ну хорошо. Тогда давайте представим себе ситуацию, когда нам нужно разместить динамические объекты какого-нибудь класса MyClass
в двумерном динамическом массиве. Как это выглядит (пример иллюстрирует исключительно использование указателей, приведенный в примере класс никакой смысловой нагрузки не несет):4. Указатель как аргумент функции
Для начала создадим два динамических массива размером 4x4 и проинициализируем их элементы некоторыми значениями:
Функция f1
выводит значения массивов на экран: первый ее аргумент указатель на двумерный массив, второй - его размерность (указывается одно значение, потому как мы условились для простоты работать с массивами, где количество строк совпадает с количеством столбцов).
Однако, нам интересен случай, когда массивы обрабатываются в некоторой функции. Что первое приходит на ум? Передать указатели в качестве параметров нашей функции и там сделать то же самое: присвоить указателю a
значение указателя b
. То есть реализовать следующую функцию:
Вариант третий, или работа над ошибками по второму варианту:
Таким образом, в main"е мы создаем указатель d
на указатель a
, и именно его передаем в качестве аргумента в функцию замены. Теперь, разыменовав
d
внутри f4
и приравняв ему значение указателя b
, мы заменили значение настоящего указателя a
, а не его локальной копии, на значение указателя b
.
