Операции с указателями. Что значит в си: что такое указатель Указатели на функции
Указатель - это переменная, содержащая адрес некоторого объекта в оперативной памяти (ОП). Смысл применения указателей - косвенная адресация объектов в ОП, позволяющая динамически менять логику программы и управлять распределением ОП.
Основные применения:
- работа с массивами и строками;
- прямой доступ к ОП;
- работа с динамическими объектами, под которые выделяется ОП.
Описание указателя имеет следующий общий вид:
Тип *имя;
то есть, указатель всегда адресует определённый тип объектов ! Например,
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. Написать свои версии функций преобразования строки в число и числа в строку. При изучении Си у начинающих часто возникают вопросы связанные с указателями, думаю вопросы у всех возникают примерно одинаковые поэтому опишу те, которые возникли у меня. Для чего нужен указатель? Почему всегда пишут “указатель типа” и чем указатель типа uint16_t
отличается от указателя типа uint8_t
? И кто вообще выдумал указатель? Перед тем как ответить на эти вопросы, давайте вспомним, что такое указатель. Для объявления переменной как указателя необходимо перед её именем поставить *
, а для получения адреса переменной используется &
(унарный оператор взятия адреса). Теперь перейдём непосредственно к вопросам, для чего нужен указатель. Представьте что у нас есть массив, с которым мы хотим работать в функции. Для того чтобы передать массив в функцию его надо скопировать, то есть потратить память, которой у МК и так мало, поэтому более правильным решение будет не копировать массив, а передать адрес его первого элемента и размер. И тут же возникает вопрос, для чего везде пишут тип перед указателем? Все просто, передавая адрес первого элемента массива и размер массива, мы говорим: Вот отсюда(указатель) выкопать 10 ямок(размер массива), приходим через два часа, а те, кто должны были выкопать ямки, вызвали трактор и роют котлован. Чтобы не попасть в такую ситуацию надо было указать размер ямки, в нашей аналогии тип указателя так, как тип определяет сколько байт будет занимать переменная в памяти. Таким образом, указывая тип указателя, мы говорим компилятору, вот тебе адрес начала массива, один элемент массива занимает 2 байта, таких элементов в массиве 10 итого сколько памяти выделить под этот массив? 20 байт - отвечает компилятор. Для наглядности давайте возьмем указатель типа void, для него не определено сколько места он занимает
- это просто адрес, приведём его к указателям разного типа и выполним операцию разадресации. Ну и последний вопрос, кто выдумал эту бяку указатель. Для того чтобы разобраться в этом вопросе, надо обратиться к ассемблеру, например AVR, и там мы найдём инструкции Указатель – это производный тип, который представляет собой адрес какого-либо значения. В языке Си++ используется понятие адреса переменных. Работа с адресами досталась Си++ в наследство от языка Си. Предположим, что в программе определена переменная типа int: int x;
Можно определить переменную типа "указатель" на целое число: int* xptr;
и присвоить переменной xptr адрес переменной x: xptr = &x;
Надо запомнить: Таким образом, для предыдущих определений x
и y
два оператора эквивалентны: // присвоить переменной y значение x
int y = x;
// присвоить переменной y значение,
// находящееся по адресу xptr
int y = *xptr;
С помощью операции обращения по адресу можно записывать значения: // записать число 10 по адресу xptr
*xptr = 10;
После выполнения этого оператора значение переменной x станет равным 10, поскольку xptr указывает на переменную x. Указатель – это не просто адрес, а адрес величины определенного типа. Указатель xptr – адрес целой величины. Определить адреса величин других типов можно следующим образом: // указатель на целое число без знака
unsigned long* lPtr;
// указатель на байт
char* cp;
// указатель на объект класса Complex
Complex* p;
Если указатель ссылается на объект некоторого класса, то операция обращения к атрибуту класса вместо точки обозначается "->", например p->real. Если вспомнить один из предыдущих примеров: void Complex::Add(Complex x)
This->real = this->real + x.real;
This->imaginary = this->imaginary +
X.imaginary;
то this – это указатель на текущий объект, т.е. объект, который выполняет метод Add. Запись this-> означает обращение к атрибуту текущего объекта. Можно определить указатель на любой тип, в том числе на функцию или метод класса. Если имеется несколько функций одного и того же типа: int foo(long x);
int bar(long x);
можно определить переменную типа указатель на функцию и вызывать эти функции не напрямую, а косвенно, через указатель: int (*functptr)(long x);
functptr = &foo;
(*functptr)(2);
functptr = &bar;
(*functptr)(4);
Для чего нужны указатели? Указатели появились, прежде всего, для нужд системного программирования. Поскольку язык Си предназначался для "низкоуровневого" программирования, на нем нужно было обращаться, например, к регистрам устройств. У этих регистров устройств вполне определенные адреса, т.е. необходимо было прочитать или записать значение по определенному адресу. Благодаря механизму указателей, такие операции не требуют никаких дополнительных средств языка. int* hardwareRegiste =0x80000;
*hardwareRegiste =12;
Однако использование указателей нуждами системного программирования не ограничивается. Указатели позволяют существенно упростить и ускорить ряд операций. Предположим, в программе имеется область памяти для хранения промежуточных результатов вычислений. Эту область памяти используют разные модули программы. Вместо того, чтобы каждый раз при обращении к модулю копировать эту область памяти, мы можем передавать указатель в качестве аргумента вызова функции, тем самым упрощая и ускоряя вычисления. Последнее обновление: 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);
Объявление и
инициализация переменной-указателя.
Указатели представляют собой переменные,
значениями которых являются адреса
памяти. Указатель содержит адрес
переменной, в которой находится конкретное
значение. Переменная непосредственно
ссылается на значение, а указатель
косвенно ссылается на значение. Ссылка
на значение через посредство указателя
называется косвенной адресацией. Указатели,
как и любые другие переменные, должны
быть объявлены, прежде чем они будут
использоваться. В
операторе 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. Какая операция
используется для организации вызова
по ссылке?
Указатель - это переменная, которая содержит адрес некоторого элемента данных(переменной, константы, функции, структуры).
char a = "a";
char *p = &a;
В данном случае в р содержится адрес переменной а. Но что интересно, для дальнейшей работы с указателем не надо писать звёздочку, она нужна только при объявлении
.
char a = "a";
char b = "b";
char *p = &a;
p = &b;
В данном случае в р содержится адрес переменной b, но если мы хотим получить значение лежащее по этому адресу, то нужно использовать оператор разыменования
, та же звёздочка *.
char new_simbol = 0;
char a = "a";
char *p = &a;
new_simbol = *p;
Таким образом, переменная new_simbol будет содержать ascii код символа "a".
m ={1,2,3...};
Можно это сделать так
void foo(char *m, uint8_t size)
{
}
или так
void foo(char m, uint8_t size)
{
}
Поскольку имя массива, содержит адрес его первого элемента, это есть не что иное, как указатель. Перемещаться по массиву можно с помощью простейших арифметических операций, например, для того чтобы получить значение пятого элемента массива, необходимо к адресу массива(адрес первого элемента) прибавить 4 и применить оператор разыменования.
m = *(m + 4);
Также в функцию можно передать и указатель на структуру. Так как разметка структуры известна, нам достаточно передать только адрес её начала, а компилятор сам разобьёт её на поля.
st X, r1 ;сохранить содержимое r1 в SRAM по адресу Х, где X – пара регистров r26, r27
ld r1,X ; загрузить в r1 содержимое SRAM по адресу Х, где X – пара регистров r26, r27
Становится понятно, что Х содержит указатель
(адрес) и, оказывается, нет никакого злого дядьки, который придумал указатель, чтобы запудрить всем мозги, работа с указателями(адресами) поддерживается на уровне ядра МК.Присваивание
Разыменование указателя
Адрес указателя
Операции сравнения
Приведение типов
