Тема Указатели и массивы Лекция 03.10.11г. 1

линейную последовательность пронумерованных ячеек памяти – байтов и каждая ячейка

памяти имеет адрес.
Будем также считать, что компьютер имеет 32-разрядную архитектуру и адреса записываются как 32-битные коды.
Наименьший адрес: 0x00000000, наибольший – 0xFFFFFFFF.
Адресуемый объем памяти – 232 байт = 4 Гбайт

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

участка, который и считается адресом данного объекта.
В языке С имеется специальная унарная операция & для получения адреса объекта d в оперативной памяти.
Функция printf имеет специальный формат %p для вывода адреса.

#include
#include
int x;
short y;
char a[256], b[512];
int fact(int n) {
return n ? n * fact(n-1) : 1;
}
main() {
printf("addr(x) = %p\n", &x);
printf("addr(y) = %p\n", &y);
printf("addr(a) = %p\n", &a);
printf("addr(b) = %p\n", &b);
printf("addr(fact) = %p\n", &fact);
system("PAUSE");
return 0;
}

взятия адреса &, т.к. они сами и являются адресами.
К их

числу относятся функции и массивы, т.е. значением имени функции и значением имени массива является адрес.
Доказательство этого:

#include
#include
int x;
short y;
char a[256], b[512];
int fact(int n) {
return n ? n * fact(n-1) : 1;
}
main() {
printf("addr(x) = %p\n", &x);
printf("addr(y) = %p\n", &y);
printf("addr(a) = %p\n", a);
printf("addr(b) = %p\n", b);
printf("addr(fact) = %p\n", fact);
system("PAUSE");
return 0;
}

a означает то же, что и &a
b означает то же, что и &b
fact означает то же, что и &fact

предположить, что память объектам программы выделяется блоками, кратными 16 байт.
Проведем

эксперимент - вместо y определим массив из 8 элементов, а размер массива b увеличим на 1:

#include
#include
int x;
short y[8];
char a[256], b[512+1];
int fact(int n) {
return n ? n * fact(n-1) : 1;
}
main() {
printf("addr(x) = %p\n", &x);
printf("addr(y) = %p\n", y);
printf("addr(a) = %p\n", a);
printf("addr(b) = %p\n", b);
printf("addr(fact) = %p\n", fact);
system("PAUSE");
return 0;
}

и могут участвовать в арифметических операциях. Проверим это:
#include
#include
int

x;
short y[8];
char a[256], b[512+1];
int fact(int n) {
return n ? n * fact(n-1) : 1;
}
main() {
printf("addr(x) = %p\n", &x);
printf("addr(x)+2 = %p\n", &x+2);
printf("addr(y) = %p\n", y);
printf("addr(y)-128 = %p\n", y-128);
printf("addr(a) = %p\n", a);
printf("addr(a)+2 = %p\n", a+2);
printf("addr(b) = %p\n", b);
printf("addr(b)+528 = %p\n", b+528);
printf("addr(fact) = %p\n", fact);
printf("addr(fact)+2 = %p\n", fact+2);
system("PAUSE");
return 0;
}

увеличился на 0x404-0x3FC=8 , т.е. увеличение в 4 раза больше

(а размер переменной типа int как раз и = 4 байтам)

short y[8]: при уменьшении адреса на 128 результат уменьшился на 0x51DC-0x50DC=0x100=256 , т.е. уменьшение в 2 раза больше (а размер переменной типа short как раз и = 2 байтам)

char a[256]: при увеличении адреса на 2 результат увеличился на 0xDE-0xDC=2 , что и требовалось, потому что размер переменной типа char = 1 байту
char b[513]: увеличение адреса на 528 в точности дало адрес переменной x.

int fact(int n): при увеличении адреса на 2 результат увеличился также на 2, что позволяет предположить, что «тип адреса» функции такой же, что и тип адреса переменной char .

адреса можно вычитать целые значения. При этом результат операции зависит

от типа переменной, адрес которой участвует в операции. Если для данного типа размер переменной равен n байт и к адресу прибавляется i, то величина адреса изменится на i*n.
Никакие другие операции к адресам неприменимы, т.е. адреса нельзя умножать, делить, складывать между собой и пр.
Исключением является операция вычитания адресов однотипных объектов, результатом которой является целое число, равное количеству объектов данного типа, которые могут разместиться на участке памяти между адресами-операндами.

b[512+1];
int fact(int n) {
return n ? n * fact(n-1)

: 1;
}
main() {
printf("addr(b)-addr(a) = %d\n", b-a);
printf("addr(a)-addr(b) = %d\n", a-b);
printf("addr(y)-addr(a) = %d\n", (char*)y-a);
printf("addr(y)-addr(a) = %d\n", y-(short*)a);
printf("addr(x)-addr(a) = %d\n", (void*)&x-(void*)a);
printf("addr(x)-addr(a) = %d\n", (double*)&x-(double*)a);
system("PAUSE");
return 0;
}

– указателях.
Указатели образуют не один конкретный тип данных (хотя все

указатели имеют один размер – 4 байта); типов указателей существует столько, сколько существует типов данных, т.е. для любого типа данных Т существует тип указателя Т*.
Примеры типов указателей: char*, int*, short*, long*, float*, double*, void*, …
Указатели типа void* называются нетипизированными указателями. При выполнении арифметических операций над такими указателями считается, что объекты, на которые они указывают, имеют размер 1 байт.

…
main() {
int *px = &x;
short *py = y;
char *pa = a, *pb = b;
void *pf = fact;
printf("px = %p\n", px);
printf("py = %p\n", py);
printf("pa = %p\n", pa);
printf("pb = %p\n", pb);
printf("pf = %p\n", pf);
system("PAUSE");
return 0;
}

, применяемая к значениям, являющимся адресами (указателями). Результатом этой операции

является объект программы, расположенный по данному адресу. Эта операция называется операцией ссылки по указателю, или операцией разыменования.
Операции & и * являются взаимно-дополняющими и, если они расположены подряд, взаимно компенсируют друг друга:
Пусть дано определение: int x; Тогда &x – адрес x; *&x – сама переменная x; &*&x – адрес x и т.д.

Переменная типа указатель может в разное время принимать различные значения. Следовательно, через одну и туже переменную-указатель можно обращаться к разным переменным (в разное время):

int a=2, b=3, c=4;
int* p=&a;
*p=7;
p=&b; *p=8;
p=&c; *p=9;
printf(“a=%d, b=%d, c=%d\n”, a, b, c); //a=7, b=8, c=9

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

аргументы функции являются её локальными переменными и «не видны» извне. Различие способов состоит в том, что при вызове функции её аргумент-локальная переменная получает :
в первом случае - копию значения фактического аргумента
во втором случае - ссылку на фактический аргумент (т.е. его адрес) и, следовательно, может им распоряжаться
Каждый из этих способов имеет свои преимущества и недостатки и программист должен обоснованно подходить к выбору наиболее подходящего для конкретной ситуации способа.
Наиболее известны два случая, когда необходимо использовать передачу по имени:
функция должна изменить значение передаваемого ей аргумента
размер аргумента велик и передача его по значению приведет к большим затратам памяти
В языке С «штатно» реализован первый способ, однако и второй способ легко реализуется, если в качестве аргумента передавать адрес (указатель).

значениями)
#include
#include
void swap(int *a, int *b) {
int c

= *a;
*a = *b; *b = c;
}
int main() {
int x = 5, y = 7;
printf("x = %d, y = %d\n",x,y);
swap(&x, &y);
printf("x = %d, y = %d\n",x,y);
system("PAUSE");
return 0;
}

5

7

&x

&y

x :

y :

a :

b :

swap

main

функцию по ссылке
#include
#include
int sum(int m[], int n) {

int i, s;
for(i=0, s=0; i return s;
}
#define N 100
int main() {
int z[N], i;
for(i=0; i z[i] = 2*i+1;
printf("summa = %d\n", sum(z, N));
system("PAUSE");
return 0;
}

z

50

z :

m :

n :

sum

main

400 байт

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

расположенных в памяти друг за другом непрерывно и допускающих прямой доступ к любому элементу по его номеру (индексу).
Массив характеризуется именем, типом элементов и их количеством.
Пример определения массива: int x[50]

x[0]

0

1

2

3

…

49

x[1]

x[2]

x[3]

…

…

x[49]

…

x:

addr

В языке С существует очень тесная связь между массивами и указателями, которая характеризуется простым утверждением:

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

Из этого утверждения следуют важные соотношения (здесь Т – имя типа):

x[i] эквивалентно *(x+i)
T x[] эквивалентно T *x

размер массива (количество элементов) должен быть известен в момент выделения

памяти массиву компилятором. Проблем не возникает в следующих случаях:
размер массива задается константным выражением
размер массива задается выражением, в которое входят константы и внешние по отношению к блоку, в котором производится определение массива, переменные (и эти переменные получили значения!)
размер массива не задается, а определяется списком инициализации

…
#define N 100
int n1 = 10;
int main() {
int n = 20;
int a[N], b[30], c[n1];
int g[] = {1, 2, 3, 4};
{
int d[n];
}
}

заранее (например, эта величина вводится человеком), можно использовать динамические массивы,

память для которых выделяется динамически системной функцией
void *calloc(size_t n, size_t r)
где n – количество элементов массива, r – размер элемента в байтах.
Функция возвращает нетипизированный указатель на начало массива.

#include
#include
int sum(int m[], int n) {
int i, s;
for(i=0, s=0; i return s;
}
int main() {
int i, n, *z;
printf("input n : "); scanf("%d", &n);
z = (int *)calloc(n, sizeof(*z));
for(i=0; i printf("summa = %d\n", sum(z, n));
system("PAUSE");
return 0;
}

указатели.
#include
#include
int sum(int *m, int n) {
int i,

s;
for(i=0, s=0; i return s;
}
int main() {
int i, n;
int *z, *y;
printf("input n : "); scanf("%d", &n);
y = z = (int *)calloc(n, sizeof(*z));
for(i=0; i printf("summa = %d\n", sum(y, n));
system("PAUSE");
return 0;
}

памяти». Эта ситуация может возникнуть при использовании динамического выделения памяти

функцией calloc. Для устранения этой ситуации рекомендуется освобождать неиспользуемую память с помощью функции
void free(void *p)
где p – нетипизированный указатель, получивший значение в результате вызова calloc.

…
int sum(int m[], int n) {
int i, s;
for(i=0, s=0; i return s;
}
int main() {
int i, n, *z;
void *p;
printf("input n : "); scanf("%d", &n);
z = (int *)(p = calloc(n, sizeof(*z)));
for(i=0; i printf("summa = %d\n", sum(z, n));
free(p);
system("PAUSE");
return 0;
}