Указатели

и параметры функций
Сложные описания с указателями

корректными?
int A[3]={1,3,5};

int B[3]={11,22};

int C[3]={0,1,2,3};

int D[1..3];

int M[3];

int N[]={10,20,30,40};

int P[3,5];

int Q[2][2]={{0},{0}};
Да
Да
Нет
Нет
Да
Да
Нет
Да

int i, M[3]={1};
   for(i=0;i

#define N 1000
void main() {
   int i, M[N], S1=0, S2=0;

   for(i=0; i M[i]=rand()%100;

   for(i=0; i S1+=M[i];
S1/=N;

   for(i=N/2; i S2+=M[i];
S1/=N;

   printf(”%d\n”, S1}

элементы описанного следующим образом массива?
int M[3][2];

a) A[1][1] A[1][2]

A[2][1] A[2][2] A[3][1] A[3][2]

b) A[0][0] A[1][0] A[2][0] A[0][1] A[1][1] A[2][1]

c) A[0][0] A[0][1] A[1][0] A[1][1] A[2][0] A[2][1]

d) A[0][0] A[0][1] A[1][0] A[0][2] A[2][0] A[2][3]

Так

(байт)
Каждая ячейка имеет собственный адрес (порядковый номер)
Адрес – целое число,

чаще записываемое в шестнадцатеричной системе счисления

0x2c4b1

Память:

Адрес:

0x2c4b2

0x2c4b3

0x2c4b4

0x2c4b5

0x2c4b6

0x2c4b7

(количество ячеек зависит от типа переменной)
Адрес переменной – адрес первой

из этих ячеек

Память:

Адрес:

x

y

a

0x2c4b1

0x2c4b2

0x2c4b3

0x2c4b4

0x2c4b5

0x2c4b6

0x2c4b7

операции &
Например, &x даст адрес x:
10
127
20031
Память:
Адрес:
x
y
a
0x2c4b1
0x2c4b2
0x2c4b3
0x2c4b4
0x2c4b5
0x2c4b6
0x2c4b7
...
printf(“x=%d, &x=%p”, x, &x); ...
x=10,

&x=2c4b1

разадресации * – обратная к операции &
0x2c4b1
0x2c4b2
0x2c4b8
0x2c4b9
0x2c4ba
0x2c4bb
int x;

/*целая переменная*/ int *px; /*указатель*/ px = &x; /*присвоить адрес*/

int x=10, y; int *px; px = &x; /*взять адрес*/ y = *px; /*взять значение по адресу px, y=10*/
*px = 20; /* <=> x=20 */

обозначающее недействительный адрес



NULL – макроконстанта
NULL чаще всего (но не

всегда!) равен 0
Разадресовывать указатель со значением NULL небезопасно!

int *px; /*указатель*/
px = NULL; /*присвоить NULL*/

можно сравнивать: < > = == != (т.е. вычислять отношения

адресов)

int y, *px=NULL, *py=&y, *pz=py; /* инициализация */

int x=10, y=20, *px, *py;
px=&x;
py=px;

int x=10, y=20, *px=&x, *py=&y;
if( px == py ) ...

Результат сложения – адрес, смещенный на N компонент соответствующего типа

относительно исходного

short x=10, *px=&x; /* инициализация */

Результат сложения – адрес, смещенный на N компонент соответствующего типа

относительно исходного

short x=10, *px=&x; /* инициализация */
px=px+1;

Результат сложения – адрес, смещенный на N компонент соответствующего типа

относительно исходного

short x=10, *px=&x; /* инициализация */
px=px+1;
px=px-2;

0

…

10

345

…

x

0x2c4b1

0x2c4b2

0x2c4b3

0x2c4b4

0x2c4b5

0x2c4b6

px

0x2c4b1

…

Результат сложения – адрес, смещенный на N компонент соответствующего типа

относительно исходного

short x=10, *px=&x; /* инициализация */
px=px+1;
px=px-2;
px++;

0

…

10

345

…

x

0x2c4b1

0x2c4b2

0x2c4b3

0x2c4b4

0x2c4b5

0x2c4b6

px

0x2c4b3

…

Результат сложения – адрес, смещенный на N компонент соответствующего типа

относительно исходного

short x=10, *px=&x; /* инициализация */
px=px+1;
px=px-2;
px++; *(px+1)+=1;

0

…

10

346

…

x

0x2c4b1

0x2c4b2

0x2c4b3

0x2c4b4

0x2c4b5

0x2c4b6

px

0x2c4b3

…

относительному смещению с учетом типа указателя


short *px=0x2c4b1, *py=0x2c4b5, d;
d

= py-px; /* 2 */

…) неявно задают длину фрагмента памяти (4,1,8, …), начинающегося с

адреса, хранимого указателем
Длина важна при разадресации и адресной арифметике
Однако иногда приходится использовать указатели, не подразумевая длины адресуемого фрагмента памяти – void *
Разадресация указателя void * невозможна!
Указатель void * совместим по типу со всеми типизированными указателями

int i=10, *pi=&i;
double d=3.14, *pd=&d;
void *p;
p=pi; /* Ok */
p=pd; /* Ok */
*p=*p+1; /* Ошибка! */

* const ptrName = &aTYPEVar;
Переменная-указатель – константа (не может изменяться)
Данные,

адресуемые указателем – изменяемые

int a=42, b=42;
int* const ptr=&a;

*ptr=1; /* Ok */
ptr=&b /* Ошибка! */

данные
Синтаксис: const TYPE * ptrName = &aTYPEVar;
Переменная-указатель – может изменяться
Данные,

адресуемые указателем – неизменяемые

int a=42, b=42;
const int *ptr=&a;

*ptr=1; /* Ошибка! */
ptr=&b /* Оk */

массивы

в языке Си
Имя массива – константный указатель на 0-й элемент

массива




a[i] == *(a+i)

short a[100];
short *ps;

ps = &a[0];

short a[100];
short *ps;

ps = a;

<=>

i[a]
a[2] == *(a+2) == *(2+a) == 2[a]





short a[100];

for (i=0;i

scanf(“%h”,&a[i]);

short a[100];

for (i=0;i<100;i++)
scanf(“%h”,a+i);

<=>

short a[100];
short *ps;
for (ps=a;ps==a+100;ps++)
scanf(“%h”,ps);

<=>

short a[100];
short *ps=a;
for (i=0;i<100;i++)
scanf(“%h”,&ps[i]);

<=>

параметра
int a[10];

f(a); /* или */
f(&a[0]);
void f(int *array){

...
}

/*или*/
void f(int array[]){
...
}

массива компилятору нужно «знать» количество столбцов в матрице (т.е. мало

знать начальный адрес масива)
Пусть нужно передать в функцию массив int array[3][15], чтобы ее вызов выглядел так: f(array)
Возможны следующие идентичные варианты описания функции f:
f(int x[3][15]) { … }
f(int x[][15]) { … }
f(int (*x)[15]) { … }
Важно: в последнем случае нельзя опустить скобки!
f(int *x[15]) { … } – передается массив из 15 указателей на int, а не указатель на массив из 15 int-ов

лишь в момент исполнения
Требуется динамически распределять массив в памяти
Стандартная функция

malloc() позволяет запросить память у ОС
Для использования malloc() нужно подключать stdlib.h
Полный прототип функции: void *malloc(size_t size);



malloc() возвращает нетипизированный указатель на начальный байт выделенного массива. Для дальнейшего использования обычно указатель преобразуют в типизированный

Указатель на первый байт массива или NULL, если выделить память не удалось

Требуемое количество байт

int *a;

/* Выделение 4 Мб памяти = 1Мб int-ов

*/
a = (int *)malloc(1024*1024*sizeof(int));

if(a == NULL) {
printf(“Ошибка выделения памяти.\n”);
return;
}

... /* Работа с элементами a[i] */

/* Освобождение памяти */
free(a);
}

память , выделенную malloc()
Блоки памяти освобождаются целиком, т.е. невозможно частичное

освобождение (см. также функцию realloc())
Полный прототип функции: void free(void *ptr);

Адрес начала освобождаемого фрагмента памяти

функции
Как описывается указатель на функцию?











Тип возвращаемого значения функции
Указатель на функцию
Тип

параметра функции

Тип параметра функции

float myfun(int a, float b) {
return a+b;
}
...
float (*fptr)(int,float);
fptr = myfun;
...
x=fptr(42,3.14f);
...

Указатель на функцию, воспринимающую параметры типов int и float и возвращающую float

Вызов функции по указателю

{ return x+y; }
int sub(int x, int y) { return

x-y; }
int mul(int x, int y) { return x*y; }
int div(int x, int y) { return x/y; }

int evaluate(unsigned int op, int x, int y) {
int (*eval[])(int, int) = { add, sub, mul, div };

if (op>3) {
printf(“Недопустимая операция”);
return 0;
}

return eval[op](x, y);
}

void main() {
printf(“%d\n”, evaluate(3, 42, 3));
}

Операции пронумерованы 0 – add, 1 – sub, 2 – mul, 3 – div

Массив из указателей на функции вида int f(int,int)

Вызов подходящей функции

не значение, а адрес переменной
#include
void swap(int *x, int *y)

{
int t;
t = *x; *x = *y; *y = t;
}
void main() {
int a=5, b=10;
swap(&a, &b);
printf(“a=%d, b=%d\n”, a, b);
}

Для доступа к значению переменной используется операция разадресации

При описании параметров функции используются указатели

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

swap(int *x, int *y) {
int t;
t = *x;

*x = *y; *y = t;
}
void main() {
int a=5, b=10;
swap(&a, &b);
printf(“a=%d, b=%d\n”, a, b);
}

y

t

x = &a; /*в х – адрес a*/ y = &b; /*в y – адрес a*/ t = *x; /*в t поместить значение, хранящееся по адресу x*/ *X = *y; /*по адресу x записать значение, хранящееся по адресу y*/ *y = t; /*по адресу y записать значение, хранящееся в t*/

typedef

указатель на char

int (*x)[13] x: указатель на массив из 13 int-ов

int

*x[13] x: массив из 13 указателей на int

void *comp() comp: функция, возвращающая указатель на void

void (*comp)() comp: указатель на функцию, возвращающую void

char (*(*x())())[5] x: функция, возвращающая указатель на массив из 5 указателей на функцию, возвращающую char

char (*(*x[3])())[5] x: массив из 3 указателей на функцию, возвращающую указатель на массив из 5 char-ов

объявления используйте следующие три правила:
Начинайте с имени переменной (d

или foo в примерах выше)
Заканчивайте на имени типа (double или char выше)
Идите вправо пока можно, затем влево (влево необходимо идти при обнаружении закрывающейся скобки)
Например

double **d[8] /* хмм... */
char *(*(**foo [][8])())[] /* упс! что такое foo? */

хмм... */
char *(*(**foo [][8])())[] /* упс! что такое foo? */

сложных объявлений?
Ответ: использовать оператор typedef
double **d[8] /* хмм... */
char *(*(**foo

[][8])())[] /* упс! что такое foo? */

typedef float real; /* real – синоним float */
typedef unsigned char byte; /* byte – синоним unsigned char */
typedef int *INTPTR; /* INTPTR – синоним int* */
typedef void (*FUNCPTR)(); /* FUNCPTR – указатель на функцию */ /* с прототипом void f() */

real r=0.0; /* то же, что и float r=0.0 */
byte b=0; /* то же, что и unsigned char b=0 */
INTPTR p; /* то же, что и int *p */
FUNCPTR pf; /* то же, что и void (*pf)() */
FUNCPTR paf[10]; /* массив из указателей на функции void (*pf)() */

Указатели и параметры функций
Сложные описания с указателями


Н.Копейкин Металлурги и компьютер