Указатели и массивы

/* strcpy: копирует t в s; вариант с индексируемым массивом*/

На практике strcpy так не пишут. Опытный программист предпочтет более короткую запись:

/* strcpy: копирует t в s; версия 2 (с указателями) */

void strcpy(char *s, char *t)

{ while ((*s++ = *t++) != '\0'); }

Приращение s и t здесь осуществляется в управляющей части цикла. Значением *t++ является символ, на который указывает переменная t перед тем, как ее значение будет увеличено; постфиксный оператор ++ не изменяет указатель t, пока не будет взят символ, на который он указывает. То же в отношении s: сначала символ запомнится в позиции, на которую указывает старое значение s, и лишь после этого значение переменной s увеличится. Пересылаемый символ является одновременно и значением, которое сравнивается с '\0' . В итоге копируются все символы, включая и заключительный символ '\0'.

Замечание: сравнение с '\0' здесь лишнее (поскольку в Си ненулевое значение выражения в условиитрактуется и как его истинность), мы можем сделать еще одно и последнее сокращение текста программы:

/* strcpy: копирует t в s; версия 3 (с указателями) */

void strcpy(char *s, char *t)

{ while (*s++ = *t++); }

Хотя на первый взгляд то, что мы получили, выглядит загадочно, все же такая запись значительно удобнее, и следует освоить ее, поскольку в Си-программах вы будете с ней часто встречаться.

3.2. Указатели и аргументы функций

Поскольку в Си функции в качестве своих аргументов получают значения параметров, нет прямой возможности, находясь в вызванной функции, изменить переменную вызывающей функции.

В программе сортировки нам понадобилась функция swap, меняющая местами два неупорядоченных элемента.

Однако недостаточно написать

swap(a, b);

где функция swap определена следующим образом:

void swap(int x, int y) /* НЕВЕРНО */

{

int temp;

temp = x;

x = y;

y = temp;

}

Поскольку swap получает лишь копии переменных a и b, она не может повлиять на переменные а и b той программы, которая к ней обратилась.

Чтобы получить желаемый эффект, вызывающей программе надо передать указатели на те значения, которые должны быть изменены:

swap(&a, &b);

Так как оператор & получает адрес переменной, &a есть указатель на a. В самой же функции swap параметры должны быть объявлены как указатели, при этом доступ к значениям параметров будет осуществляться косвенно.

void swap(int *px, int *py) /* перестановка *рх и *рy */

{

int temp;

temp = *рх;

*рх = *py;

*рy = temp;

}

Аргументы-указатели позволяют функции осуществлять доступ к объектам вызвавшей ее программы и дают возможность изменить эти объекты.

3.3. Указатели на функции

Функция располагается в памяти по определенному адресу, который можно присвоить указателю в качестве его значения. Адресом функции является ее точка входа. Именно этот адрес используется при вызове функции. Так как указатель хранит адрес функции, то она может быть вызвана с помощью этого указателя. Он позволяет также передавать ее другим функциям в качестве аргумента.

В программе на С адресом функции служит ее имя без скобок и аргументов (это похоже на адрес массива, который равен имени массива без индексов).

Возможны только две операции с функциями: вызов и взятие адреса. Указатель, полученный с помощью последней операции, можно впоследствии использовать для вызова функции.

Пример 2. 

 void error(char* p) { /* ... */ }

 void (*efct)(char*);                     // указатель на функцию

void f()

{ efct = &error;                            // efct настроен на функцию error

  (*efct)("error");                          // вызов error через указатель efct

  }

Для вызова функции с помощью указателя (efct в нашем примере) надо вначале применить операцию косвенности к указателю - *efct. Поскольку приоритет операции вызова () выше, чем приоритет косвенности *, нельзя писать просто *efct("error"). Это будет означать *(efct("error")), что является ошибкой. По той же причине скобки нужны и при описании указателя на функцию. Однако, писать просто efct("error") можно, т.к. транслятор понимает, что efct является указателем на функцию, и создает команды, делающие вызов нужной функции.

4. Массивы указателей. Указатели на указатели

4.1. Массивы указателей

Массив указателей (МУ) – простейшая структура данных, в которой проявляется различие между физическим и логическим порядком следования элементов. Способ организации данных ясен уже из самого определения: это массив, каждый элемент которого содержит указатель на переменную (объект).

Если это записать в терминах контекстного определения переменных, то получим, например

double  *p[20];

 Переменную p следует понимать как массив (операция []), каждым элементом которого является указатель на переменную типа double (операция *). Переменная p является массивом указателей как тип данных, но не является таковой как структура данных. Чтобы превратиться в структуру данных, она быть дополнена указуемыми переменными и указателями (связями).

Многообразие вариантов реализации массивов указателей возникает по нескольким причинам:

• cам массив указателей, указуемые переменные и ссылки (указатели) могут быть заданы статически (в тексте программы), либо динамически созданы во время ее выполнения;
• двоякая интерпретация указателя как указателя на отдельную переменную и на массив переменных (строку), позволяет создавать одномерные СД – массивы указателей на переменные и двумерные – массивы указателей на массивы (строки) таких переменных;
• указуемые переменные могут быть «собственностью» структуры данных, однако массив указателей может ссылаться и на переменные (объекты), являющиеся составными частями других структур данных.

Основная сложность заключается в том, что во всех случаях используются одни и те же типы данных, а конкретный вид структуры данных определяется контекстом их использования в тексте программы.

4.2. Типы данных, используемые при работе с массивами указателей

Один тип данных уже был нами упомянут – это массив указателей, переменная вида int *p[]. 

Кроме нее используется еще одни тип вида int **pp, который можно определить в общем виде как указатель на указатель.

Указатель на указатель таким образом допускает целых четыре интерпретации. При этом для каждой из них должна быть создана (инициализирована) своя структура данных. Положение усугубляется еще и тем, что за соответствием структуры данных и операциями над ней должен следить программист (компилятор этого не делает).

Первый вариант – указатель на указатель на отдельную переменную, имеет довольно специфическое применение. Обычно от используется для передачи адреса заголовкакакой-либо структуры данных при необходимости его изменения. В формальных параметрах для этой цели предпочтительнее использование ссылки на указатель.

Пример 1.

int a=5, b=10;

int *p=&a;

int **pp=&p;

(**pp)++;  *pp=&b; **pp=0;

Второй вариант также довольно экзотичен – указатель на указатель на линейный массив переменных. В выражениях, которые используются в такой структуре данных присутствуют приоритетные скобки, поскольку операция косвенного обращения на первом уровне предшествует операции индексации на втором.

Пример 2.

int a[10]=5, b[10]=10;

int *p=a; int **pp=&p;

for (int i=0;i<10;i++) (*pp)[i]=0;

*pp=b;

for (int i=0;i<10;i++)

{

(*pp)++;

**pp=i;

 }

В остальных вариантах тип данных int** применяется для работы с массивами указателей.

Классическая интерпретация - указатель на массив указателей на отдельные объекты использует естественный порядок операций *p[i] для доступа к указуемым объектам.

Пример 3.

int a=5, b=10, с=15;

int *p[]={&a,&b,&c,NULL};

 int **pp=p;

for (int s=0,i=0;i<10;i++)  s=s+*pp[i];

Массив указателей на линейные массивы переменных является двумерной структурой данных и использует двойную индексацию. Функционально она является эквивалентом двумерного массива.

Пример 4.

int a[]={5,6,7,8}, b[]={1,2,3,4}, с[]={5,2,4,8};

int *p[]={a,b,c};

int **pp=p;

for (int s=0,i=0;i<3;i++) 

for (int j=0;j<4;j++)

s=s+pp[i][j];

4.3. Статические и динамические массивы указателей

Статический массив указателей формируется при трансляции: переменные (сам массив указателей и указуемые переменные) определяются статически, как обычные именованные переменные, а указатели инициализируются. Структура данных включена непосредственно в программный код и «готова к работе».

int a1,a2,a3, *pd[] = { &a1, &a2, &a3, NULL};

Промежуточные варианты массива указателей могут содержать как статические, так и динамические компоненты.

Пример 5. Статический массив указателей программно заполняется адресами элементов статического же массива (динамически формируются только сами указатели).

int d[19], *pd[20];

for (i=0; i<19; i++) pd[i] = &d[i];

pd[i] = NULL;

Указуемые переменные могут создаваться динамически, их адреса заполняют статический массив указателей.

int *p, *pd[20];

for (i=0; i<19; i++){ p = new int; *p = i;  pd[i] = p; }

pd[i] = NULL;

Наконец, если массив указателей формируется как динамическая структура данных, то динамический массив указателей создается в процессе работы программы. Операция new в качестве результата возвращает указатель на область памяти, содержащую указатели, т.е. тип int**, который запоминается в переменной того же типа.

int **pp, *p;

pp = new int *[20];                      // память под массив указателей из 20 указателей типа int*

for (i=0; i<19; i++)

{

p = new int;

*p = i;

pp[i] = p;                                      // можно pp[i]=new int; *pp[i]=i;

}

pp[i] = NULL;

4.4. Массив указателей. Физический и логический порядок

При работе с массивом указателей используются два контекста:

1. pp[i] -i-й указатель в массиве;
2. *pp[i] -значение i-ой указуемой переменной.

Алгоритмы работы с массивом указателей и обычным массивом внешне очень похожи. Разница же состоит в том, что размещение данных в обычном массиве соответствует их физическому порядку следования в памяти, а массив указателей позволяет сформировать логический порядок следования элементов в соответствии с размещением указателей на них.  Тогда изменение порядка следования (включение, исключение, упорядочение, перестановка), которое в обычном массиве заключается в перемещении самих элементов, в массиве указателей должно сопровождаться операциями над указателями на них. Очевидные преимущества возникают, когда сами указуемые переменные являются достаточно большими, либо перемещение их невозможно по каким-либо причинам (например, на них ссылаются другие части программы).

Пример 6. Для сравнения приведем функции сортировки массива и массива указателей.

//  Сортировка массива

void sort1 (double d[],int sz)

{

int i,k;

do {

for ( k=0, i=0; i<sz-1; i++)

if (d[i] > d[i+1])

{

 double c;

 c = d[i];

 d[i] = d[i+1];

 d[i+1] = c;

k=1;

}

} while (k);

}

//  Сортировка массива указателей

 void sort2 (double *pd[])

{

int i,k;

do {

for ( k=0, i=0; pd[i+1]!=NULL;i++)

if (*pd[i] > *pd[i+1])                          // Сравнение указуемых переменных

{

double *c;                                            // Перестановка указателей

c = pd[i];

 pd[i] = pd[i+1];

pd[i+1] = c;

k = 1;

}

} while (k);

}

5 Динамические переменные

5.1. Создание динамических переменных

Для создания динамических переменных служат функции malloc и calloc. Они описаны в библиотеке alloc.h.

Вид обращения к функциям:

1. malloc(size), где size (типа unsigned) - объем памяти, который необходимо выделить;
2. calloc(nelem,elsize), где nelem (типа unsigned) - число элементов, для которых надо выделить память; elsize (типа unsigned) - объем памяти, который необходимо выделить для каждого элемента.

Обе функции выделяют основную память и возвращают указатель на тип void, содержащий адрес выделенной области памяти. Если памяти недостаточно, функции возвращают NULL.

Функция calloc, кроме отведения памяти, присваивает каждому элементу значение 0, что очень удобно для автоматического создания массивов.

То, что функции имеют тип void (и, значит, возвращают результат типа void), означает, что они возвращают нетипизированный указатель, значение которого затем можно присваивать указателю любого типа данных без предварительного преобразования типов.

Но это справедливо лишь в Турбо-СИ, поэтому для переносимости программного обеспечения лучше всегда использовать явное преобразование типа.

Для определения необходимого объема памяти можно использовать унарную операцию sizeof (размер). Эта операция используется в двух формах:

1) sizeof(<выражение>)

2) sizeof(<тип>)

Частный случай выражение - константа или переменная. Результат выполнения операции - количество байтов, занимаемых операндом, то есть объем памяти в байтах, необходимый для хранения:

1) значения выражения;

2) значения заданного типа.

Пример 1. Пример иллюстрирует результат выполнения операции sizeof

#include <stdio.h>

main ()

{int b; float d[500];

printf("\nРазмер памяти под целое %d",sizeof(int));                       /* Результат: 2 */

printf("\nРазмер памяти под переменную b %d",sizeof(b));           /* Результат: 2 */

printf("\nРазмер памяти под d %d", sizeof d);                                 /* Результат: 2000 */

}

Пример 2. Пример динамического распределения памяти

/* Динамическое создание одной переменной типа int */

#include <stdio.h>

#include <alloc.h>

main()

{int *iptr;                                  /* iptr - указатель на целое */

iptr=(int *) malloc(sizeof(int));

*iptr=421;          /* *iptr - это имя динамической переменной. Ее значение равно 421.*/

printf("Содержимое iptr: %p\n",iptr);             /* Вывод: Содержимое iptr: <адрес> */

printf("Адресуемое значение: %d\n",*iptr); /* Вывод: Адресуемое значение: 421 */

}

Оператор "iptr=(int*) malloc(sizeof(int));" выполняет следующие действия:

1) выражение sizeof(int) возвращает количество байтов, требуемых для хранения переменной типа int (для компилятора Турбо-Си на IBM PC это значение равно 2);

2) функция malloc(n) резервирует n последовательных байтов доступной (свободной) памяти в компьютере, и возвращает начальный адрес размещения в памяти этой последовательности байтов;

3) выражение (int *) указывает, что этот начальный адрес есть указатель на данные типа int. Это выражение явного приведения типа. Для Турбо-Си это приведение необязательно, но для других компиляторов Си является обязательным. Из соображения переносимости программного обеспечения лучше всегда предусматривать явное приведение типов в своих программах;

4) адрес, полученный с помощью функции malloc , запоминается в iptr. Таким образом, получена динамически созданная целая переменная, к которой можно обращаться при помощи имени "*iptr".

Краткая формулировка действий: "выделить в памяти компьютера некоторый участок для переменной int, затем присвоить начальный адрес этого участка переменной iptr, являющейся указателем на переменную типа int".

Делать присваивание "*iptr=421" без предварительного присвоения адреса в iptr нельзя, так как нет гарантии, что iptr указывает на свободный участок памяти. Вообще, правило использования указателей: указатель всегда должен иметь адрес до своего использования в программе.

Пример 3. Динамическое распределение памяти. Адресная арифметика

/* Динамическое создание трех переменных типа int */

#include <stdio.h>

#include <alloc.h>

main()

{

#define n 3

int *list, i;

list=(int *) calloc(n,sizeof(int));

*list=421;

*(list+1)=53;

*(list+2)=1806;

printf("\nСписок адресов :");

for (i=0;i<n;i++)

printf("%4p ",(list+i));

printf("\nСписок значений :");

for (i=0;i<n;i++)

printf("%4d", *(list+i));

printf("\n");

}

/* list указывает на участок памяти размером 3*2=6 байтов, достаточный для хранения 3-х элементов типа int. */

/* list+i представляет адрес памяти, определяемый выражением list+(i*sizeof(int)). */

Пример 4. В примере указатель инициализируется в момент описания.

#include <alloc.h>

main()

{ int *y=(int *)malloc(sizeof(int));

/* Указатель y инициализируется в момент описания; то есть здесь y оп

• 2015 Февраль
• 2015 Май
• 2015 Июнь
• 2016 Май
• 2017 Май
• 2017 Ноябрь