Понятие указателя, описание и инициализация указателей. Операции над указателями. Выражения с указателями. Примеры.
С указателями можно использовать только 4 арифметические операции:
++,--,+,-
Указатели можно использовать в большинстве с++ выражений, но необходимо соблюдать определенные правила, т.к. указатели хранят адрес переменной, а не ее значение.
Также указатели можно сравнивать.
Массивы и их описание. Инициализация и ввод-вывод массивов. Примеры обработки массивов.
Инициализация,ввод вывод
Структура одномерного массива:
Массивы занимают смежные ячейки памяти.
Строки являются одномерными массивами.
Двумерные и многомерные массивы:
Объявление:
int example[2][2];
Инициализация и вывод такие же, только в 2х и более циклах
Операции над массивами.
Сортировка методом пузырька:
Модульный принцип программирования. Описание, структура функции и ее вызов. Примеры
Модульное программирование - это организация программы как совокупности небольших независимых блоков (модулей), структура и поведение которых подчиняется определенным заранее правилам.
Модулем (в модульном программировании) называется множество взаимосвязанных подпрограмм (процедур) вместе с данными, которые эти подпрограммы обрабатывают.
Функции:
Объявление
func(type param1,…type paramN);
Описание:
func(type param1,…type paramN)
{
….код
}
Вызов:
func(param1…paramN);
Пример:
#include <iostream>
#include <conio.h>
using namespace std;
double myFunc(double x,double y);
int main()
{ double x, y;
cout << "Input x and y: ";
cin >> x >> y;
cout << "Result: " << myFunc(x,y);
cout << "\nIn Main()\n"<< "Press any key to exit...";
getch();
}
double myFunc(double x, double y)
{
if(x*y>100)
return 100;
return x*y;
}
Если использовать модульный принцип, то под каждый модуль(функцию) нужно созавать отдельный заголовочный и cpp файл а потом инклудить их.
Блочная структура программного модуля. Классы хранения (памяти) объектов программы. Примеры.
В языке C имеется 4 класса памяти:
extern (внешние переменные);
auto (автоматические переменные);
register (регистровые переменные);
static (статические переменные);
Время жизни – это интервал времени выполнения программы, в течение которого программный объект (переменная или функция) существует, что определяется фактом выделения памяти. Время жизни переменной может быть локальным или глобальным. Переменная с глобальным временем жизни имеет выделенную память и определенное значение на протяжении всего времени выполнения программы, начиная с момента объявления этой переменной. Переменная с локальным временем жизни имеет выделенную память и определенное значение только во время выполнения блока, в котором эта переменная объявлена. При каждом входе в блок локальной переменной выделяется новая память, которая освобождается при выходе из блока.
Область видимости – это часть текста программы, в которой может быть использован данный объект. Объект считается видимым в блоке или в исходном файле, если в этом блоке или файле известны имя и тип объекта. Объект может быть видимым в пределах блока, текущего файла или во всех файлах, образующих программу.
Время жизни и область видимости объекта зависят от того, в каком месте объявлен объект. Если объект объявлен на внутреннем уровне, т. е. внутри некоторого блока, то по умолчанию он имеет локальное время жизни и локальную область видимости, т. е. он существует, пока выполняется блок, и видим в этом блоке и во всех внутренних блоках (локальная переменная). Если объект объявлен на внешнем уровне, т. е. вне всех блоков, он имеет глобальное время жизни и глобальную видимость. Такой объект существует до завершения программы и видим от точки его объявления до конца данного исходного файла (глобальная переменная).
Изменить время жизни переменной и область ее видимости можно, если указать для нее класс памяти. Все переменные, которые использовались до сих пор, были известны только содержащим их функциям. В C имеются возможности сделать ряд переменных известными сразу нескольким функциям и быстро обработать переменные путем помещения их значений в регистры и т. д. Эти и другие возможности реализуются при помощи присваивания переменным класса памяти.
Служебное слово, определяющее класс памяти, ставится в описаниях переменных перед служебным словом, задающим тип переменных:
static int i,j;
extern char ch1;
register int k;
Область памяти, в которой размещается программа, делится на разделы по назначению и способам управления данными:
· сегмент кода используется для хранения кода программы – функций. Функции помещаются в сегмент кода на этапе компиляции программы и находятся там до завершения работы программы, поэтому все функции в C имеют глобальное время жизни и существуют в течение всего времени выполнения программы;
· статическая память (сегмент данных) предназначена для хранения переменных в течение всего времени выполнения программы. Если для переменной в какой-либо момент работы программы выделена память в сегменте данных, она там будет находиться до завершения работы программы, даже если эта переменная больше не нужна. По умолчанию в сегменте данных хранятся глобальные переменные;
· стек – это область памяти, в которой хранятся локальные переменные и параметры функций. При вызове функции ее параметры и локальные переменные помещаются в стек. Стек функционирует по принципу стакана – значение, помещенное в стек первым, оказывается на дне стека, в то время как последнее значение – на вершине стека. По завершении работы функции все данные, принадлежащие этой функции, удаляются из стека. Очистка стека начинается с вершины, т. е. со значений, помещенных в стек последними;
· динамическая память (куча) позволяет программисту управлять процессом выделения памяти под переменные и освобождением памяти. Переменные, размещаемые в динамической памяти, называются динамическими переменными. О них речь пойдет в гл.14, посвященной динамическому распределению памяти.
Объекты класса auto имеют локальное время жизни и локальную область видимости – только ту функцию или тот блок, где они объявлены. Такие переменные называются автоматическими. По умолчанию, т. е. без указания класса, все переменные, объявленные внутри блока, относятся к классу auto. Переменная класса auto начинает существовать при входе в блок, в котором она объявлена. Память под автоматическую переменную выделяется в стеке. При выходе из блока переменная автоматически исчезает. При этом память, отведенная под эту переменную, освобождается. При повторном входе в блок для этой переменной может быть выделен другой участок памяти.
Объекты класса register также имеют локальное время жизни и локальную область видимости, однако в отличие от автоматических переменных, они размещаются на регистрах процессора и называются регистровыми переменными. Использование регистровой памяти обычно приводит к сокращению времени доступа к переменной. Если по каким-либо причинам переменная не может быть размещена на регистрах процессора, она помещается в стек. Регистровая переменная может быть только целочисленной, и к ней нельзя применить операцию & (получение адреса).
Переменные, объявленные внутри блока со спецификатором класса памяти static, обеспечивают возможность сохранить значение переменной при выходе из блока и использовать его при повторном входе в блок. Такие переменные называются статическими. Статическая переменная имеет глобальное время жизни и одновременно локальную область видимости – она доступна только внутри блока, в котором объявлена. В отличие от переменных с классом auto, для переменных с классом static память выделяется в сегменте данных при объявлении переменной, и поэтому их значение сохраняется при выходе из блока.
Переменные класса памяти static могут быть инициализированы константным выражением. Если явной инициализации нет, то такой переменной присваивается нулевое значение. При инициализации константным адресным выражением можно использовать адреса любых внешних объектов, кроме адресов объектов с классом памяти auto, так как адрес последних не является константой и изменяется при каждом входе в блок. Инициализация выполняется один раз при первом входе в блок.
Переменная, объявленная с классом памяти extern, является ссылкой на глобальную переменную, объявленную в одном из исходных файлов программы с тем же самым именем. Цель такого объявления состоит в том, чтобы сделать доступной переменную, созданную в другом файле. Переменные класса extern называются внешними переменными. Объявление переменной со спецификатором extern информирует компилятор о том, что память для переменной выделять не требуется, так как это уже выполнено где-то в другом месте программы. Также внешнюю переменную нельзя инициализировать, поскольку она инициализируется в другом месте.
При объявлении переменных на внешнем уровне их можно объявлять без указания класса памяти или использовать спецификатор класса памяти static или extern.
Объявление статических переменных на глобальном уровне может задаваться в следующих формах:
· переменная объявлена с классом памяти static. Такая переменная может быть инициализирована явно константным выражением или по умолчанию нулевым значением. Таким образом, объявления static int i=0 и static int i эквивалентны, и в обоих случаях переменной i будет присвоено значение нуль;
· переменная объявлена без указания класса памяти, но с явной инициализацией. Такой переменной по умолчанию присваивается класс памяти static. Таким образом, объявления int i=1и static int i=1 будут эквивалентны.
Объявление внутри блока переменной класса static позволяет создать переменную с глобальным временем жизни, но с локальной видимостью.
Рассмотрим пример.
Функция print выводит на экран значения статической переменной stat, автоматической переменной av, параметра функции p:
#include <stdio.h>
void print(int); //Прототип функции print()
int main(void)
{
int count;
for(count=9; count>=5; count-=2)
print(count); //Вызов функции print()
return 0;
}
//Определение функции print()
void print(int p)
{
int av=1;
static int stat=1;
printf("p=%d stat=%d av=%d\n",p,stat,av);
stat++;av++;
return 0;
}
Переменная p получает свое значение из функции main(), меняющееся от 9 до 5 с шагом 2. Статическая переменная stat создается в сегменте данных при первом вызове функции print()и получает начальное значение, равное единице. Функция увеличивает это значение на единицу. Переменная stat находится в сегменте данных, при повторном вызове функции print()переменная stat «вспоминает» свое прошлое значение. Локальная (автоматическая) переменная av при каждом вызове функции создается заново, каждый раз инициализируется и при выходе из функции перестает существовать.
В результате выполнения этого примера на экран будет выведена следующая информация:
p=9 stat=1 av=1
p=7 stat=2 av=1
p=5 stat=3 av=1
Глобальная переменная может быть определена только один раз в пределах своей области видимости. В другом исходном файле может быть объявлена другая глобальная переменная с таким же именем и с классом памяти static, конфликта при этом не возникает, так как каждая из этих переменных будет видимой только в своем исходном файле.
Внешняя переменная представляет собой ссылку на глобальную переменную с таким же именем. Внешние переменные могут объявляться как на внешнем уровне, так и внутри блока. Внешние переменные могут объявляться как в файлах, не содержащих глобальную переменную, так и в файлах, где эта переменная объявлена. Глобальная переменная видима в пределах файла, в котором она объявлена, начиная с места объявления. Выше своего описания и в других файлах эта переменная невидима. Создание внешней переменной класса extern в качестве ссылки на глобальную переменную, объявленную в другом месте программы, расширяет область видимости этой переменной. При этом область видимости глобальной переменной расширяется от места объявления внешней переменной до конца файла или блока, в котором сделано объявление.
В объявлениях с классом памяти extern не допускается инициализация, так как эти объявления ссылаются на уже существующие и определенные ранее переменные. Переменная, на которую делается ссылка с помощью спецификатора extern, может быть определена только один раз в одном из исходных файлов программы.
Рассмотрим следующий пример. Глобальная переменная a объявлена в середине текста программы таким образом, что функция summa() находится вне области видимости переменной. Чтобы функция summa() могла использовать переменную a, внутри функции объявляется внешняя переменная:
#include <stdio.h>
void summa()
{
extern float a;
float b=8;
float y=a+b;
printf("Summa=%f\n",y);
}
float a=10;
int main()
{
summa();
return 0;
}
После завершения работы программы на экран будет выведено значение 18.