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

 

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

Рассмотрим следующие операторы:

int mas[N];

int *p;

Первый из них описывает целочисленный массив размерностью N, а второй – указатель на целочисленную переменную, который пока ни на что не указывает. Если выполнить присваивание

p = &mas[0];

то теперь указатель p будет содержать адрес начального элемента массива mas, или, другими словами, будет указывать на элемент mas[0] (точнее, на первый байта элемента mas[0], т.к. значение типа int хранится в 4-х байтах).

Как только такое присваивание выполнено, можно применять правила адресной арифметики над указателями, суть которых заключается в том, что, если указатель p указывает на некоторый элемент массива, то p, увеличенный на единицу, будет указывать на следующий элемент, а p, увеличенный на i, будет указывать на i -й элемент по отношению к элементу, на который он указывал вначале.

 

p ®	mas[0]
p + 1 ®	mas[1]
p + 2 ®	mas[2]
...	...
p+N-1 ®	mas[N-1]

 

Так как операция разадресации (*) позволяет получить значение элемента массива, на который указывает указатель, то можно записать следующее:

*p = mas[0];

*(p+1) = mas[1];

*(p+2) = mas[2];

...

*(p+N-1) = mas[N-1];

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

p = &mas[0];

можно заменить на

p = mas;

С учетом этого можно записать, что:

*mas = mas[0];

*(mas +1) = mas[1];

*(mas +2) = mas[2];

...

*(mas +N-1) = mas[N-1];

Между указателем p и именем массива mas существует одно существенное различие. Указатель p – это переменная, предназначенная для хранения любых адресов, поэтому можно, например, написать:

p++;

p += i;

Но имя массива mas не является переменной, это указатель-константа на начальный элемент массива, и записи типа:

mas++;

mas += i;

недопустимы.

Пример 1: вывести на экран значения всех элементов массива, введенных с клавиатуры.

#include <stdio.h>

void main()

{

const int N = 10;

int i, mas[N];

int *p;

p = mas;

//Ввод (один из вариантов)

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

scanf(“%d”, p+i);

//Вывод: вариант 1

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

printf(“%d ”, *(p+i));

//Вывод: вариант 2

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

{

printf(“%d ”, *p);

p++;

}

//Вывод: вариант 3

p = mas;

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

printf(“%d ”, *p++);

//Вывод: вариант 4

p = mas;

for (i = 0; i < N; p++, i++)

printf(“%d ”, *p);

//Вывод: вариант 5

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

printf(“%d ”, *(mas+i));

//Вывод элементов массива в обратном порядке (один из вариантов)

p = &mas[N-1];

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

printf(“%d ”, *(p-i));

}

 

Пример 2: вывести на экран все значения элементов двумерного массива.

#include <stdio.h>

void main()

{

const int N = 2, M = 4;

int mas[N ][M], *p, i, j;

p = &mas[0][0]; //можно p = mas[0] или p = *mas;

//Ввод (один из вариантов)

for (i = 0; i < N*M; i++)

scanf(“%d”, p+i);

//Вывод: вариант 1

for (i = 0; i < N*M; i++)

printf("%d%c", *p++, (i+1)%M? ' ': '\n');

//Вывод: вариант 2

p = mas[0];

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

{

for (j = 0; j < M; j++)

printf("%d ", *(p+i*M+j));

printf("\n");

}

//Вывод: вариант 3

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

{

for (j = 0; j < M; j++)

printf("%d ", *(mas[i]+j));

printf("\n");

}

//Вывод: вариант 4

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

{

for (j = 0; j < M; j++)

printf("%d ", *(*(mas+i)+j));

printf("\n");

}

}

Эти варианты программы основаны на следующей схеме взаимосвязей между указателями и элементами двумерного массива:

p = mas[0] = *mas ®	mas[0][0]
p+1 = mas[0]+1 = *mas+1 ®	mas[0][1]
p+2 = mas[0]+2 = *mas+2 ®	mas[0][2]
p+3 = mas[0]+3 = *mas+3 ®	mas[0][3]
p+4 = mas[1] = *(mas+1) ®	mas[1][0]
p+5 = mas[1]+1 = *(mas+1)+1 ®	mas[1][1]
p+6 = mas[1]+2 = *(mas+1)+2 ®	mas[1][2]
p+7 = mas[1]+3 = *(mas+1)+3 ®	mas[1][3]

 

 

Тема 8. Строки символов

 

Строка представляет собой массив символов, заканчивающийся нуль-символом. Нуль-символ – это символ с кодом, равным нулю, что записывается в виде управляющей последовательности ‘\0’. По положению нуль-символа определяется фактическая длина строки. Строку можно инициализировать строковой константой:

char str[50] = “Vasia”; //первые элементы массива str: ‘V’, ‘a’, ‘s’, ‘i’, ‘a’, ‘\0’

Можно не указывать размерность массива:

char str[ ] = “Vasia”; //выделяется память под 6 элементов: 5 букв и нуль-символ

Возможна инициализация с помощью набора символьных констант:

char str[50] = {‘V’, ‘a’, ‘s’, ‘i’, ‘a’}; // первые элементы: 5 букв и нуль-символ

Если размерность не указывать, то к инициализаторам нужно обязательно добавить нуль-символ:

char str[ ] = {‘V’, ‘a’, ‘s’, ‘i’, ‘a’, ‘\0’}; //выделяется память под 6 элементов

 

Для ввода данных с клавиатуры в строку символов используются функции gets, scanf, getchar. Для вывода содержимого строки на экран используются функции puts, printf, putchar. Все эти функции описаны в заголовочном файле stdio.h:

#include <stdio.h>

void main()

{

const int N = 50;

char str1[N], str2[N], str3[N], str4[N];

int i;

//ввод: вариант 1

gets(str1); //в str1 вводится строка символов. Окончание ввода – по нажатию //клавиши ВВОД (Enter)

//ввод: вариант 2

scanf("%s", str2); //в str2 вводится строка в которой недопустимы пробельные

//символы. Окончание ввода – по нажатию клавиши ВВОД или клавиши ПРОБЕЛ.

fflush(stdin); //очистка потока ввода stdin

 

//ввод: вариант 3

scanf("%10c", str3); //в str3 вводится 10 символов (завершение ввода клавишей ВВОД)

str3[10] = ‘\0’; //с помощью операции присваивания добавляется нуль-символ

fflush(stdin); //очистка stdin, если с помощью scanf было введено > 10 символов

 

//ввод: вариант 4

i = 0;

while(1)

{

str4[i] = getchar();

if (str4[i] == ‘\n’) break;

i++;

}

str4[i] = ‘\0’; //последний введенный символ (‘\n’) заменяется на ‘\0’

// вывод: вариант 1

puts(str1); //вывод str1 и переход на начало новой строки

// вывод: вариант 2

printf("%s\n", str2); //вывод str2 и переход на начало новой строки

// вывод: вариант 3

i = 0;

while(str3[i]!= ‘\0’) //можно записать короче: while(str3[i])

{

printf("%c", str3[i]); //можно совместить 2 строки: printf("%c", str3[i++]);

i++;

}

printf("\n");

 

// вывод: вариант 4

i = 0;

while(str4[i]!= ‘\0’) //можно записать короче: while(str4[i])

{

putchar(str4[i]); //можно совместить 2 строки: putchar(str4[i++]);

i++;

}

}

 

Пример программы копирования одной строки в другую:

#include <stdio.h>

void main()

{

const int N = 50;

char str1[N], str2[N] = “\”Zubilo\” – chempion”;

char *p1 = str1, * p2 = str2;

 

//вариант 1

int i = 0;

do

str1[i] = str2[i];

while(str1[i++]!= ‘\0’); //можно записать короче: while(str1[i++]);

 

//вариант 2

int i = 0;

while(1);

{

str1[i] = str2[i];

if (str1[i++] == ‘\0’) break; //можно записать короче: if (!str1[i++]) break;

}

 

//вариант 3

int i = 0;

while((str1[i] = str2[i])!= ‘\0’) //можно записать короче: while(str1[i] = str2[i])

i++;

 

//вариант 4

while((*p1 = *p2)!= ‘\0’)

{

p1++;

p2++;

}

 

//вариант 5

while((*p1++ = *p2++)!= ‘\0’);

 

//вариант 6

while(*p1++ = *p2++);

//вывод результата копирования на экран

puts(str1); //можно и так: p1 = str1; puts( p1 );

}

Тема 9. Структуры

 

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

Сначала структуру нужно объявить (декларировать). Объявление структуры начинается с ключевого слова struct и содержит список описаний, заключенный в фигурные скобки, например:

struct point

{

int x, y;

char color[20];

};

где point – это имя структуры.

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

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

struct point A, B, C;

с точки зрения синтаксиса аналогична записи:

int a, b, c;

и описывает 3 переменные структурного типа с именами A, B, C. Одновременно можно выполнить инициализацию полей структур:

struct point A = {50, 50, “Red”}, B, C = {100, 100, “Green”};

Можно совместить объявление структуры с описанием переменных структурного типа:

struct point

{

int x, y;

chat color[20];

} A = {50, 50, “Red”}, B, C;

Более того, если кроме A, B и C нам больше не нужны переменные этого типа, то имя point можно опустить.

Доступ к отдельному полю структуры выполняется посредством конструкции вида:

ИмяСтруктуры.ИмяПоля

Например, введем с клавиатуры данные в поля структуры B, а затем выведем эти данные на экран:

scanf("%d%d%s", &B.x, &B.y, &B.color);

printf("(%d, %d) %s", B.x, B.y, B.color);

Если описать указатель на структуру, то с его помощью можно также получить доступ к полям структуры посредством конструкции вида:

УказательНаСтруктуру->ИмяПоля

Например:

struct point *p;

p = &B;

scanf("%d%d%s", &p->x, &p->y, &p->color);

printf("(%d, %d) %s\n", p->x, p->y, p->color);

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

struct rect //задает прямоугольник, стороны которого ||-ы осям координат

{ // pt1 и pt2 – угловые точки, лежащие на диагонали прямоугольника

struct point pt1;

struct point pt2;

} R;

R.pt1.x = R.pt1.y = 50;

R.pt1.color = “Red”;

R.pt2.x = R.pt2.y = 100;

R.pt2.color = “Green”;

Массивы структур

В практике программирования большое распространение получили массивы структур, т.е. массивы, элементами которых являются переменные структурного типа. Например, оператор

struct point mas[3];

описывает массив, состоящий из трех элементов типа struct point. Описание можно дополнить инициализацией:

struct point mas[ ] = {{10, 10, “Red”}, {20, 20, “Green”}, {30, 30, “Blue”}};

Если инициализаторы – простые константы или строки символов, и все они имеются в наличии, во внутренних скобках нет необходимости:

struct point mas[ ] = {10, 10, “Red”, 20, 20, “Green”, 30, 30, “Blue”};

Ввод данных в массив структур с клавиатуры и вывод их на экран можно выполнить следующим образом:

int i;

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

{

scanf(“%d%d%s”, &mas[i].x, &mas[i].y, &mas[i].color);

printf("(%d, %d) %s", mas[i].x, mas[i].y, mas[i].color);

}

То же самое с использованием механизма указателей:

struct point *p;

p = mas;

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

{

scanf("%d%d%s", &(p+i)->x, &(p+i)->y, &(p+i)->color);

printf("(%d, %d) %s", (p+i)->x, (p+i)->y, (p+i)->color);

}

Битовые поля

Битовые поля – это особый вид полей структуры. Они используются для плотной упаковки данных, например, флажков типа «да/нет». Это объясняется тем, что минимальная адресуемая ячейка оперативной памяти имеет длину один байт (8 бит), в то время как для хранения флажка достаточно одного бита. При описании битового поля после имени через двоеточие указывается длина поля в битах. Битовые поля могут быть любого целого типа и обычно используется тип unsigned int (сокращенно unsigned). Например:

struct options

{

unsigned bold: 1;

unsigned italic: 1;

unsigned underline: 1;

unsigned background: 4;

} opt;

Под переменную opt структурного типа options будет отведена память размером 1 байт (если не использовать битовые поля, то структурная переменная будет занимать минимум 4 байта).

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

Объединения

Объединение представляет собой частный случай структуры, все поля которой располагаются по одному и тому же адресу. Формат описания такой же, как и у структуры, только вместо ключевого слова struct используется слово union. Длина объединения равна наибольшей из длин его полей. В каждый момент времени объединение хранит только одно значение, и ответственность за его правильное использование лежит на программисте.

Объединения применяют для экономии памяти в тех случаях, когда известно, что больше одного поля одновременно не требуется. Пример:

#include <stdio.h>

void main()

{

int payType; //тип платежа

union payment

{

char card[25]; //оплата по карте

int check; //оплата чеком

} info;

// ... присваивание значений переменным payType и info

switch (payType)

{

case 0: printf("Оплата по карте: %s", info.card); break;

case 1: printf("Оплата чеком: %d", info.check); break;

}

}

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

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

#include <stdio.h>

void main()

{

struct

{

int payType;

union

{

char card[25];

int check;

};

} info;

// ... присваивание значения переменной info

switch (info.payType)

{

case 0: printf("Оплата по карте: %s", info.card); break;

case 1: printf("Оплата чеком: %d", info.check); break;

}

}

Перечисления

Перечисление – это список именованных целых констант. Для описания перечисления используется следующий формат:

enum [имяПеречисления] {списокИменованныхКонстант};

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

enum boolean {NO, YES}; // NO = 0, YES = 1

boolean bool; //описали переменную bool типа boolean

bool = YES; // bool = 1

 

enum months {JAN=1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC};

months mon; // FEB=2, MAR=3, APR=4,..., DEC=12

mon = DEC; // mon = 12

enum controls {BELL=’\a’, BACKSPACE=’\b’, NEWLINE=’\n’, TAB=’\t’, VTAB=’\v’};

char ch;

while(1)

{

if ((ch = getchar()) == NEWLINE) break;

...

}

 

Пример формирования на экране меню

#include <stdio.h>

void main()

{

enum menu {READ=1, WRITE, APPEND, EXIT};

int num;

do

{

printf("1. Читать\n");

printf("2. Писать\n");

printf("3. Дописать в конец\n");

printf("4. Выйти\n");

printf("\nВаш выбор?\n");

scanf("%d", &num);

if (num == EXIT) break;

switch (num)

{

case READ:...; break;

case WRITE:...; break;

case APPEND:...; break;

default: printf("Неверный ввод\n"); break;

}

} while(1);

}

 

Переименование типов

 

Для того, чтобы сделать программу более ясной, можно дать типу новое имя с помощью ключевого слова typedef:

typedef Тип НовоеИмяТипа[Размерность];

Размерность может отсутствовать. Примеры:

typedef unsigned int uint;

typedef char message[100];

typedef char * string;

Введенные таким образом имена можно использовать таким же образом, как и имена простых типов данных:

uint i, j; //две переменные типа unsigned int

message str[10]; //массив из 10 строк по 100 символов в каждой строке

string p = str; //инициализированный указатель на char

Кроме задания типам с длинными описаниями более коротких имен, typedef используется для облегчения переносимости программ: если машинно-зависимые типы объявить с помощью операторов typedef, при переносе программы потребуется внести изменения только в эти операторы.

 

Тема 10. Функции

 

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

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

Любая функция должна быть определена. Определение функции состоит из заголовка и тела:

тип имя ([список параметров]) //заголовок функции

{

тело функции

}

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

Тело функции представляет собой последовательность описаний и операторов в фигурных скобках. Пример:

int sumFunc(int n, int m, int p)

{

int result; //эту и 2 последующие строки можно

result = n + m + p; //заменить одной строкой:

return result; // return = n + m + p;

}

Эта простейшая функция, имя которой sumFunc, предназначена для нахождения суммы трех целых чисел n, m и p, которые передаются ей в качестве параметров. Возврат из функции подсчитанной суммы выполняется с помощью оператора, имеющего следующий формат:

return [выражение];

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

void main()

{

int a = 10, b = 20, c = 30, res;

puts("a = 10, b = 20, c = 30");

res = sumFunc(a, b, c); //эту и следующую строки можно совместить:

printf("a + b + c = %d", res); // printf("a + b + c = %d", sumFunc(a, b, c));

}

Если в программе сначала определить главную функцию main, а затем – функцию sumFunc, то перед функцией main нужно будет поместить так называемый прототип функции sumFunc, иначе при выполнении оператора

res = sumFunc(a, b, c);

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

#include <stdio.h>

int sumFunc(int n, int m, int p); //прототип функции sumFunc

void main() //определение функции main

{

int a = 10, b = 20, c = 30;

puts("a = 10, b = 20, c = 30");

printf("a + b + c = %d", sumFunc(a, b, c)); //вызов функции sumFunc

}

int sumFunc(int n, int m, int p) //определение функции sumFunc

{

return n + m + p;

}

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

int sumFunc(int, int, int);

Глобальные, локальные и статические переменные

Все величины, описанные внутри функции, а также ее параметры, являются локальными объектами. Областью их действия является функция. При выходе из функции локальные объекты разрушаются и, следовательно, значения локальных переменных между вызовами одной и той же функции не сохраняются. Если этого требуется избежать, при объявлении локальных переменных используется модификатор static. Статическая переменная инициализируется только один раз при первом выполнении оператора, содержащего ее описание, и сохраняет свое значение между вызовами содержащей ее функции:

#include <stdio.h>

void func(int n)

{

static int a = 0;

a += n;

printf("%d ", a);

}

void main()

{

func(5);

func(5);

func(5);

}

Результат работы программы:

5 10 15

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

Параметры функции

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

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

Существует два способа передачи параметров в функцию: по значению и по адресу.

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

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

По умолчанию параметры любого типа, кроме массива и функции, перелаются в функцию по значению.

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

swap(a, b);

функции, имеющей прототип

void swap(int n, int m);

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

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

swap(&a, & b);

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

void swap(int *pn, int *pm)

{

int temp;

temp = *pn;

*pn = *pm;

*pm = temp;

}