- •Министерство образования Республики Беларусь
- •1. Что такое программа на языке программирования
- •2. Общее знакомство с языком с
- •3. Структура простой программы на языке с
- •4. Что такое программа на языке с
- •5. Представление информации и типы данных в языке с
- •6. Константы
- •7. Переменные
- •8. Элементарный вВод и вывод информации
- •9. Выражения и операции
- •9.1. Арифметические операции
- •9.2. Операция изменения знака
- •9.3. Операции инкремента и декремента
- •9.4. Операция присваивания
- •9.6. Поразрядные логические операции
- •9.8. Логические операции и операции отношения
- •9.9. Условная операция «? :»
- •9.10. Операция последовательного вычисления
- •9.11. Операция определения требуемой памяти в байтах sizeof
- •9.12. Операция приведения типа (type)
- •10. Операторы управления вычислительным процессом
- •10.1. Операторы ветвления if и else
- •10.2. Оператор switch
- •10.3. Оператор цикла while
- •10.4. Оператор цикла do…while
- •10.5. Оператор цикла for
- •10.6. Бесконечные циклы
- •10.7. Другие управляющие средства языка с
- •10.8. Стандартные математические функции
- •11. Вычисление выражений и побочные эффекты
- •11.1. Преобразования типов при вычислении выражений
- •11.2. Побочные эффекты при вычислении выражений
- •12. Массивы
- •12.1. Описание массива
- •12.2. Инициализация массива
- •12.3. Ввод-вывод массива
- •12.4. Двумерные массивы (массивы массивов)
- •13. Указатели
- •14. Адресная арифметика
- •15. Массивы и указатели
- •15.1. Указатели и одномерные массивы
- •15.2. Указатели и двумерные массивы
- •16. Строки
- •17. Массивы строк
- •18. Функции
- •18.1. Определение функции в языке с
- •18.2. Возвращение значений из функции
- •18.3. Формальные и фактические параметры функции
- •18.4. Вызов функции
- •18.5. Объявление и определение функции: прототип функции
- •19. Передача параметров в функции
- •19.1. Способы передачи параметров в функции
- •19.2. Передача параметров в функции в языке с
- •19.3. Передача указателей в функции
- •20. Классы хранения и видимость переменных
- •20.1. Общие положения
- •20.2. Спецификаторы класса памяти
- •20.3. Область видимости функций
- •20.4. Глобальные переменные
- •20.5. Глобальные статические переменные
- •20.6. Локальные переменные
- •20.7. Статические локальные переменные
- •20.8. Регистровые переменные
- •20.9. Выводы
- •21. Организация памяти программы
- •22. Многофайловая компиляция (проекты)
- •23. Передача в функции массивОв
- •23.1. Передача одномерных массивов в функции
- •23.2. Передача двумерных массивов в функции
- •23.3. Передача в функции символьных строк
- •23.4. Возвращение указателей из функций
- •24. Функции с переменным количеством аргументов
- •24.1. Соглашения о вызовах: модификаторы функций
- •24.2. Объявление списка параметров переменной длины
- •25. Передача параметров в функцию main()
- •26. Указатели на функцию
- •27. Стандартные функцИи языка с
- •27.1. Функции для работы со строками
- •27.2. Функции для проверки символов и преобразования данных
- •27.3. Функция быстрой сортировки – gsort()
- •27.4. Функция двоичного поиска – bsearch()
- •28. Работа с файлами
- •28.1. Основные понятия
- •28.2. Основные функции для работы с файлами
- •28.3. Открытие и закрытие файлов
- •28.4. Ввод/вывод символов
- •28.5. Ввод/вывод строк
- •28.6. Форматированный ввод/вывод
- •28.7. Ввод/вывод блоков данных
- •28.8. Другие средства для работы с файлами
- •28.9. Ввод/вывод низкого уровня (префиксный доступ к файлам)
- •29. Типы, определяемые пользователем: Перечисления, структуры и объединения
- •29.1. Переименование типов – оператор typedef
- •29.2. Перечисления (enum)
- •29.3. Основные сведения о структурах
- •29.4. Структурные переменные в памяти компьютера
- •29.5. Доступ к полям структуры
- •29.6. Массивы структур
- •29.7. Структуры и функции
- •29.8. Объединения (union)
- •30. Динамическая память
- •30.1. Понятие динамического объекта
- •30.2 Создание и уничтожение динамических объектов
- •30.3 Динамическое размещение одномерных массивов и строк
- •30.4 Динамическое размещение двумерных массивов
- •30.5. Функции для работы с блоками памяти
- •31. Динамические структуры данных
- •31.1. Понятие структуры данных
- •31.2. Структуры, ссылающиеся на себя
- •31.3. Связанные списки
- •31.5. Очереди
- •Ниже приводятся примеры функций для очереди (структура элемента очереди совпадает со структурой элемента стека в примере выше):
- •32. Препроцессор языка с
- •32.1 Директива включения файлов
- •32.2. Директива определения макрокоманд (макросов)
- •32.3 Директива условной компиляции
- •32.4 Дополнительные директивы препроцессора
17. Массивы строк
Массив строк представляет собой обычный двумерный массив символов. При этом обязательно должно выполняться одно условие – в каждой строке такого массива должен быть ноль-символ, который определяет конец соответствующей строки массива.
Описать массив строк можно так же, как и любой другой двумерный массив.
char mas[5][10]; // будет выделена память для хранения 5 строк, каждая
// из которых может иметь длину до 9 символов.
// Первоначально содержится случайная информация
200 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
? |
210 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
? |
220 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
? |
230 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
? |
240 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
? |
Чтобы этот массив стал массивом строк, в каждой строке должен появиться ноль-символ. Тогда строкой будет все то, что находится в соответствующей строке массива до ноль-символа.
mas[0][0]=‘G’; mas[0][1]=‘G’; mas[0][2]=‘U’; mas[0][3]=0;
for (i=1; i<5; i++)
mas[i][0]=0;
200 |
G |
G |
U |
0 |
? |
? |
? |
? |
? |
? |
210 |
0 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
220 |
0 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
230 |
0 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
240 |
0 |
? |
? |
? |
? |
? |
? |
? |
? |
? |
Имеем одну строку "GGU" (mas[0]) и четыре пустые строки (mas[1], mas[2], mas[3], mas[4]). Т.е. имя массива с одним индексом является строкой символов.
Массив строк можно инициализировать при описании:
char mas [5][10] = {“май”, “июль”, “август”};
200 |
м |
а |
й |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
210 |
и |
ю |
л |
ь |
0 |
0 |
0 |
0 |
0 |
0 |
220 |
а |
в |
г |
у |
с |
т |
0 |
0 |
0 |
0 |
230 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
240 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
Или так (количество строк определится автоматически):
char mas[][10]={"май", "июль", "август"};
200 |
м |
а |
й |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
210 |
и |
ю |
л |
ь |
0 |
0 |
0 |
0 |
0 |
0 |
220 |
а |
в |
г |
у |
с |
т |
0 |
0 |
0 |
0 |
При работе с массивом строк удобно использовать массивы указателей. Память выделяется для 3 указателей (по 4 байта на каждый, например). В каждый указатель занесется адрес соответствующей константы. Правда такие строки нельзя изменять, иначе запортятся константы.
char *mas[3]={"май", "июль", "август"};
200 |
500 |
504 |
509 | |||||||||
212 |
|
|
|
|
|
|
|
|
|
|
|
|
500 |
м |
а |
й |
0 |
| ||||
504 |
и |
ю |
л |
ь |
0 |
| |||
509 |
а |
в |
г |
у |
с |
т |
0 |
В этом случае каждый элемент массива представляет собой адрес соответствующей строки символов, а сами строки располагаются компилятором в области констант (в сегменте данных загрузочного модуля программы). Никакой лишней памяти, связанной с различной длиной строк, при этом не расходуется.
Задача. Ввести и вывести массив строк. Конец ввода – пустая строка.
void main() {
int n = 0, i;
char s[10][80];
gets(s[n]);
while (s[n][0] != 0) { //*s[n]
n++;
gets(s[n]);
}
for (i=0; i<n; i++)
puts(s[i]);
}
======= второй вариант ============================
void main() {
int n = 0, i;
char s[10][80];
while (*gets(s[n])) // gets возвращает адрес строки s[n]
n++;
for (i=0; i<n; i++)
puts(*(s+i)); //адрес строки содержится в s[i]
}
Задача. Дано предложение. Сформировать массив слов из слов предложения.
void main() {
int n=0, i=0, j=0;
char s[80], w[10][80];
gets(s);
while (s[i]!=0) {
while(s[i]==' ')
i++;
if (s[i]==0) break; // чтобы не пропустить 0-символ
while (s[i]!=' ' && s[i]!=0) {
w[n][j]=s[i];
j++;
i++;
}
w[n][j]=0;
n++;
j=0;
}
for (i=0; i<n; i++)
puts(w[i]);
}
======= второй вариант ============================
void main(void){
char s[80],w[20][80];
int i=0,j,n=0;
gets(s);
while(s[i]){
while(s[i]==' ') i++;
if(!s[i])
break;
for(j=0; s[i]!=' ' && s[i]; w[n][j++]=s[i++]);
w[n++][j]=0;
}
}