- •Программирование на языке си
- •Тамбов, 1994
- •Оглавление
- •1.Описание Языка си
- •1.1. Элементы Языка си
- •1.1.1. Используемые символы
- •1.1.2. Константы
- •1.1.3. Идентификатор
- •1.1.4. Ключевые слова
- •1.1.5. Использование комментариев в тексте программы
- •1.2. Типы Данных и Их Объявление
- •1.2.1 Категории типов данных
- •1.2.2. Целый тип данных
- •1.2.3. Данные плавающего типа
- •1.2.4. Указатели
- •1.2.5. Переменные перечислимого типа
- •1.2.6. Массивы
- •1.2.7. Структуры
- •1.2.8. Объединения (смеси)
- •1.2.9. Поля битов
- •1.2.10. Переменные с изменяемой структурой
- •1.2.11. Определение объектов и типов
- •1.2.12. Инициализация данных
- •1.3. Выражения и Присваивания
- •1.3.1. Операнды и операции
- •1.3.2. Преобразования при вычислении выражений
- •1.3.3. Операции отрицания и дополнения
- •1.3.4. Операции разадресации и адреса
- •1.3.5. Операция sizeof
- •1.3.6. Мультипликативные операции
- •1.3.7. Аддитивные операции
- •1.3.8. Операции сдвига
- •1.3.9. Поразрядные операции
- •1.3.10. Логические операции
- •1.3.11. Операция последовательного вычисления
- •1.3.12. Условная операция
- •1.3.13. Операции увеличения и уменьшения
- •1.3.14. Простое присваивание
- •1.3.15. Составное присваивание
- •1.3.16. Приоритеты операций и порядок вычислений
- •1.3.17. Побочные эффекты
- •1.3.18. Преобразование типов
- •1.4. Операторы
- •1.4.1. Оператор выражение
- •1.4.2. Пустой оператор
- •1.4.3. Составной оператор
- •1.4.4. Оператор if
- •1.4.5. Оператор switch
- •1.4.6. Оператор break
- •1.4.7. Оператор for
- •1.4.8. Оператор while
- •1.4.9. Оператор do while
- •1.4.10. Оператор continue
- •1.4.11. Оператор return
- •1.4.12. Оператор goto
- •1.5.1. Определение и вызов функций
- •1.5.2. Вызов функции с переменным числом параметров
- •1.5.3. Передача параметров функции main
- •1.6.1. Исходные файлы и объявление переменных
- •1.6.2. Объявления функций
- •1.6.3. Время жизни и область видимости программных объектов
- •1.6.4. Инициализация глобальных и локальных переменных
- •1.7.1. Методы доступа к элементам массивов
- •1.7.2. Указатели на многомерные массивы
- •1.7.3. Операции с указателями
- •1.7.4. Массивы указателей
- •1.7.5. Динамическое размещение массивов
- •1.8. Директивы Препроцессора
- •1.8.1. Директива #include
- •1.8.2. Директива #define
- •1.8.3. Директива #undef
- •2. Организация списков и их обработка
- •2.1. Линейные списки
- •2.1.1. Методы организации и хранения линейных списков
- •2.1.2. Операции со списками при последовательном хранении
- •2.1.3. Операции со списками при связном хранении
- •2.1.4. Организация двусвязных списков
- •2.1.5. Стеки и очереди
- •2.1.6. Сжатое и индексное хранение линейных списков
- •2.2. Сортировка и Слияние Списков
- •2.2.1. Пузырьковая сортировка
- •2.2.2. Сортировка вставкой
- •2.2.3. Сортировка посредством выбора
- •2.2.4. Слияние списков
- •2.2.5. Сортировка списков путем слияния
- •2.2.6. Быстрая и распределяющая сортировки
- •2.3.1. Последовательный поиск
- •2.3.2. Бинарный поиск
- •2.3.3. М-блочный поиск
- •2.3.4. Методы вычисления адреса
- •2.3.5. Выбор в линейных списках
- •2.4. Рекурсия
1.7.5. Динамическое размещение массивов
При динамическом распределении памяти для массивов следует описать соответствующий указатель и присваивать ему значение при помощи функции calloc. Одномерный массив a[10] из элементов типа float можно создать следующим образом
float *a;
a=(float*)(calloc(10,sizeof(float));
Для создания двумерного массива вначале нужно распределить память для массива указателей на одномерные массивы, а затем распределять память для одномерных массивов. Пусть, например, требуется создать массив a[n][m], это можно сделать при помощи следующего фрагмента программы:
#include
main ()
{ double **a;
int n,m,i;
scanf("%d %d",&n,&m);
a=(double **)calloc(m,sizeof(double *));
for (i=0; i<=m; i++)
a[i]=(double *)calloc(n,sizeof(double));
. . . . . . . . . . . .
}
Аналогичным образом можно распределить память и для трехмерного массива размером n,m,l. Следует только помнить, что ненужную для дальнейшего выполнения программы память следует освобождать при помощи функции free.
#include
main ()
{ long ***a;
int n,m,l,i,j;
scanf("%d %d %d",&n,&m,&l);
/* -------- распределение памяти -------- */
a=(long ***)calloc(m,sizeof(long **));
for (i=0; i<=m; i++)
{ a[i]=(long **)calloc(n,sizeof(long *));
for (j=0; i<=l; j++)
a[i][j]=(long *)calloc(l,sizeof(long));
}
. . . . . . . . . . . .
/* --------- освобождение памяти ----------*/
for (i=0; i<=m; i++)
{ for (j=0; j<=l; j++)
free (a[i][j]);
free (a[i]);
}
free (a);
}
Рассмотрим еще один интересный пример, в котором память для массивов распределяется в вызываемой функции, а используется в вызывающей. В таком случае в вызываемую функцию требуется передавать указатели, которым будут присвоены адреса выделяемой для массивов памяти.
Пример:
#include
main()
{ int vvod(double ***, long **);
double **a; /* указатель для массива a[n][m] */
long *b; /* указатель для массива b[n] */
vvod (&a,&b);
.. /* в функцию vvod передаются адреса указателей, */
.. /* а не их значения */
..
}
int vvod(double ***a, long **b)
{ int n,m,i,j;
scanf (" %d %d ",&n,&m);
*a=(double **)calloc(n,sizeof(double *));
*b=(long *)calloc(n,sizeof(long));
for (i=0; i<=n; i++)
*a[i]=(double *)calloc(m,sizeof(double));
.....
}
Отметим также то обстоятельство, что указатель на массив не обязательно должен показывать на начальный элемент некоторого массива. Он может быть сдвинут так, что начальный элемент будет иметь индекс отличный от нуля, причем он может быть как положительным так и отрицательным.
Пример:
#include
int main()
{ float *q, **b;
int i, j, k, n, m;
scanf("%d %d",&n,&m);
q=(float *)calloc(m,sizeof(float));
/* сейчас указатель q показывает на начало массива */
q[0]=22.3;
q-=5;
/* теперь начальный элемент массива имеет индекс 5, */
/* а конечный элемент индекс n-5 */
q[5]=1.5;
/* сдвиг индекса не приводит к перераспределению */
/* массива в памяти и изменится начальный элемент */
q[6]=2.5; /* - это второй элемент */
q[7]=3.5; /* - это третий элемент */
q+=5;
/* теперь начальный элемент вновь имеет индекс 0, */
/* а значения элементов q[0], q[1], q[2] равны */
/* соответственно 1.5, 2.5, 3.5 */
q+=2;
/* теперь начальный элемент имеет индекс -2, */
/* следующий -1, затем 0 и т.д. по порядку */
q[-2]=8.2;
q[-1]=4.5;
q-=2;
/* возвращаем начальную индексацию, три первых */
/* элемента массива q[0], q[1], q[2], имеют */
/* значения 8.2, 4.5, 3.5 */
q--;
/* вновь изменим индексацию . */
/* Для освобождения области памяти в которой размещен */
/* массив q используется функция free(q), но поскольку */
/* значение указателя q смещено, то выполнение */
/* функции free(q) приведет к непредсказуемым последствиям. */
/* Для правильного выполнения этой функции */
/* указатель q должен быть возвращен в первоначальное */
/* положение */
free(++q);
/* Рассмотрим возможность изменения индексации и */
/* освобождения памяти для двумерного массива */
b=(float **)calloc(m,sizeof(float *));
for (i=0; i < m; i++)
b[i]=(float *)calloc(n,sizeof(float));
/* После распределения памяти начальным элементом */
/* массива будет элемент b[0][0] */
/* Выполним сдвиг индексов так, чтобы начальным */
/* элементом стал элемент b[1][1] */
for (i=0; i < m ; i++) --b[i];
b--;
/* Теперь присвоим каждому элементу массива сумму его */
/* индексов */
for (i=1; i<=m; i++)
for (j=1; j<=n; j++)
b[i][j]=(float)(i+j);
/* Обратите внимание на начальные значения счетчиков */
/* циклов i и j, он начинаются с 1 а не с 0 */
/* Возвратимся к прежней индексации */
for (i=1; i<=m; i++) ++b[i];
b++;
/* Выполним освобождение памяти */
for (i=0; i < m; i++) free(b[i]);
free(b);
...
...
return 0;
}
В качестве последнего примера рассмотрим динамическое распределение памяти для массива указателей на функции, имеющие один входной параметр типа double и возвращающие значение типа double.
Пример:
#include
#include
double cos(double);
double sin(double);
double tan(double);
int main()
{ double (*(*masfun))(double);
double x=0.5, y;
int i;
masfun=(double(*(*))(double))
calloc(3,sizeof(double(*(*))(double)));
masfun[0]=cos;
masfun[1]=sin;
masfun[2]=tan;
for (i=0; i<3; i++);
{ y=masfun[i](x);
printf("\n x=%g y=%g",x,y);
}
return 0;
}