* / %
+ -
<< >>
< > <= >=
= = !=
& ^ |
&& ||
=
*= /=
%=
+= -=
<<= >>=
&= |=
^=
Тернарная операция
- ? : a=(b>c)?b:c
#include <stdio. h>
int main(){
int a = 11, b = 4, max;
max = (b > a)? b : a;
printf("Наибольшее число: %i", max);
return 0;
}
Выражения
lВыражения состоят из операндов, знаков операций и скобок и используются для вычисления некоторого значения определенного типа
lКаждый операнд является:
- выражением константой переменной.
Примеры выражений
l(а + 0.12)/6
l х && у || !z
l(t * sin(x)-1.05e4)/((2 * k + 2) * (2 * k + 3))
Приоритеты операций
lОперации выполняются в соответствии с приоритетами.
lДля изменения порядка выполнения операций используются круглые скобки.
lЕсли в одном выражении записано несколько операций одинакового приоритета, унарные операции, условная операция и операции присваивания выполняются справа налево, остальные — слева направо.
lНапример:
nа = b = с означает а = (b=с),
nа + b + с означает (а + Ь) + с.
lПорядок вычисления подвыражений внутри выражений не определен.
lНапример, нельзя считать, что в выражении (sin(x + 2) + cos(у + 1)) обращение к синусу будет выполнено раньше, чем к косинусу, и что х + 2 будет вычислено раньше, чем y+1.
Операторы ветвления
lОператор if
lОператор switch
Условный оператор if
lУсловный оператор if используется для разветвления процесса вычислений на два направления.
lФормат оператора:
nif ( выражение ) оператор_1; [else оператор_2;]
lСначала вычисляется выражение, которое может иметь арифметический тип или тип указателя.
lЕсли оно не равно нулю (имеет значение true), выполняется первый оператор, иначе — второй.
lПосле этого управление передается на оператор, следующий за условным.
Примеры условного оператора (1)
if(a<0)
b = 1;
if(a<b && (a>d || a==0))
b++;
else
{
b*=a;
a = 0;
}
Примеры условного оператора (2)
if(a<b)
{
if(a<c)
m = a;
else
m = c;
}
else
{
if(b<c)
m = b;
else
m = c;
}
Оператор switch
lОператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений.
lФормат оператора:
switch(выражение){
case константное_выражение_1: [список_операторов_1]
case константное_выражение_2: [список_операторов_2]
…
case константное_выражение_п: [список_операторов_п]
[default: операторы ]
}
Пример использования switch
#include <iostream.h> int main(){
int a, b,res;
char op;
cout « "\пВведите 1й операнд : ”; cin » a;
cout « "\пВведите знак операции : ”; cin » op;
cout « "Введите 2й операнд : “ cin » b;
bool f = true;
switch (op){
case ‘+’ : res = a+b; break;
case ‘-’ : res = a-b; break;
case ‘/’ : res = a/b; break;
case ‘*’ : res = a*b; break;
default: cout « “Неизвестная операция"; f=false;
}
if (f) cout « “Результат : “ << res;
return 0;
}
Операторы цикла
lЦикл с предусловием (while)
lЦикл с постусловием (do while)
lЦикл с параметром (for)
Цикл с предусловием (while)
lЦикл с предусловием имеет вид:
lwhile ( выражение ) оператор;
lВыражение определяет условие повторения тела цикла, представленного простым или составным оператором.
lВыполнение оператора начинается с вычисления выражения.
nЕсли оно истинно (не равно false), выполняется оператор цикла.
nЕсли при первой проверке выражение равно false, цикл не выполнится ни разу.
lВыражение вычисляется перед каждой итерацией цикла.
Пример цикла while
#include <iostream. h>
int main(){
int num;
cout « "Введите число : ";
cin » num;
int half = num / 2; // половина числа
int div = 2; // кандидат на делитель
while (div <= half){
if(!(num % div))
cout « div <<"\n”;
div++;
}
return 0;
}
Цикл с постусловием (do while)
lЦикл с постусловием имеет вид:
ldo оператор while (выражение);
lСначала выполняется простой или составной оператор, составляющий тело цикла.
lВычисляется выражение.
nЕсли оно истинно (не равно f al se), тело цикла выполняется еще раз.
nЦикл завершается, когда выражение станет равным false.
Пример использования
do … while
#include <iostream. h>
int main(){
char answer;
do{
cout « "\пКупи слоника! ";
cin » answer;
}while (answer!= 'y');
return 0;
}
Цикл с параметром (for)
lЦикл с параметром имеет следующий формат:
lfor (инициализация; выражение; модификации) оператор;
lИнициализация используется для объявления и присвоения начальных значений величинам, используемым в цикле. Инициализация выполняется один раз в начале исполнения цикла.
lВыражение определяет условие выполнения цикла: если его результат равен true, цикл выполняется. Цикл с параметром реализован как цикл с предусловием.
lМодификации выполняются после каждой итерации цикла и служат обычно для изменения параметров цикла.
lПростой или составной оператор представляет собой тело цикла.
lЛюбая из частей оператора for может быть опущена (но точки с запятой надо оставить на своих местах!).
Пример цикла for
#include <iostream. h>
int main(){
int num;
cout « "Введите число : ": cin » num:
for (int half=num/2,div=2;div<=half;div++)
if (!(num % div))
cout« div <<"\n“;
return 0;
}
Операторы передачи управления
lоператор безусловного перехода goto;
lоператор выхода из цикла break;
lоператор перехода к следующей итерации цикла continue;
lоператор возврата из функции return.
Оператор goto
lОператор безусловного перехода goto имеет формат:
lgoto метка;
lВ теле той же функции должна присутствовать ровно одна конструкция вида:
lметка: оператор;
lОператор goto передает управление на помеченный оператор.
lМетка — это обычный идентификатор, областью видимости которого является функция, в теле которой он задан.
Оператор break
lОператор break используется внутри операторов цикла или switch для обеспечения перехода в точку программы, находящуюся непосредственно за оператором, внутри которого находится break.
Пример использования
break
#include <iostream. h>
int main(){
char answer;
while(true){
cout « "\пКупи слоника! ";
cin » answer;
if(answer == ‘y’)
break;
}
return 0;
}
Оператор continue
lОператор перехода к следующей итерации цикла continue пропускает все операторы, оставшиеся до конца тела цикла, и передает управление на начало следующей итерации.
Пример использования
continue
#include <iostream. h>
int main(){
int num;
cout « "Введите число : ": cin » num:
for (int i=0;i<=num;i++){
if(i%2)
continue;
cout« i <<"\n“;
}
return 0;
}
Оператор return
lОператор возврата из функции return завершает выполнение функции и передает управление в точку ее вызова. Вид оператора:
lreturn [ выражение ];
lЕсли тип возвращаемого функцией значения описан как void выражение должно отсутствовать.
Пример оператора return
int max(int a, int b){
if(a>b)
return a;
else
return b;
}
С++. Указатели и массивы
Основные вопросы
lПонятие указателя
lИнициализация указателей
lОперации с указателями
lСсылки
lМассивы
lСтроки
Имя и адрес переменной
Запись в программе:
int i = 10;
Понятие указателя
lУказатель – тип данных, предназначенный для хранения адресов областей памяти.
lВиды указателей (различаются свойствами и набором допустимых операций)
Указатель на объект данных
Указатель на функцию
Указатель на область памяти (void)
lПеременные – указатели подчиняются общим правилам области видимости и времени жизни переменных
Указатель на объект данных
lСодержит адрес области памяти, в которой содержаться данные определенного типа.
lОбъявление указателя: тип *имя;
lК моменту описания указателя тип должен быть объявлен, но может быть еще не определен.
lЗвездочка в объявлении относится непосредственно к имени переменной, поэтому для объявления нескольких указателей необходимо ставить звездочку перед каждым именем - int *a, b, *c;
lВ Windows размер указателя – 4 байта.
lМожно определить указатель на указатель и т. д.
lint **p;
Размещение указателей в памяти
Запись в программе:
int i = 10;
int *p = &i;
int **pp = &p;
Указатель на функцию
lСодержит адрес начала области памяти по которому располагается исполняемый код функции.
lУказатели на функции используются для
косвенного вызова функции
передачи функции в качестве параметра другой функции
lИмеет тип «указатель на функцию, возвращающую значение заданного типа и имеющие аргументы заданного типа»
lтип (*имя) (список типов аргументов)
lНапример: int (*fun)(double, double)
Пример использования указателя на функцию
bool (*eq)(double,double);
bool eqSharp(double a, double b){
if(abs(a-b) < 0.)
return true;
else
return false;
}
bool eqApp(double a, double b){
if(abs(a-b) < 0.1)
return true;
else
return false;
}
int main(){
double x, y;
…
if(…)
eq = eqSharp;
else
eq = eqApp;
if(eq(x, y))
…
…
}
Указатель на область памяти (void)
lПрименяется когда тип объекта, адрес которого требуется хранить не определен. (Например, в разные моменты времени требуется хранить адреса объектов различных типов)
lМожно присвоить значение указателя любого типа.
lМожно сравнивать с указателями любых типов.
Указатели и константы
lУказатель может быть константой или переменной, может указывать на константу или переменную
int i; // переменная
const int ci; // константа
int *pi; // указатель на переменную
const int * pci; // указатель на константу
int * const cp = &i; // Указатель-константа на переменную
const int * const cpc = &ci; //Указ.-конст. на константу
Инициализация указателей
lПрисваивание указателю адреса существующего объекта
lПрисваивание адреса в явном виде
lПрисваивание пустого значения
lВыделение участка в динамической памяти и присваивание ее адреса
Присваивание указателю адреса существующего объекта
lС помощью операции получения адреса
nt a; // переменная
int *p = &a; // в указатель записывается адрес a
int *pp(&a); // инициализация другим способом
lС помощью значения другого указателя
int *r = p;
lC помощью имени массива или функции
int b[10]; // массив
int *t = b; // присваивание адреса начала массива
…
void f(int a){…} // определение функции
void (*pf)(int); // указатель на функцию
pf = f; // присваивание адреса функции
Присваивание адреса в явном виде
char *vp = (char *)0xb8000000;
Присваивание пустого значения
int * x = NU;
int *y = LL0;
lГарантируется, что объектов с нулевым адресом существовать не может.
lНулевое значение удобно использовать когда указатель не связан с объектом.
Динамическая память
lДинамическая память (куча, heap) – память, в которой можно выделять место во время работы программы в соответствии с потребностями.
lДоступ к выделенным участкам памяти осуществляется только с помощью указателей.
l Выделенная память сохраняется до завершения программы или до ее явного освобождения.
lДля выделения памяти используются функция malloc и операция new.
lДля освобождения памяти – функция free и операция delete.
Выделение и освобождение динамической памяти
lВыделение памяти
int * p1 = new int;
int * p2 = new int (10);
int *p3 = new int[10];
nЕсли память выделить не удалось то указателю присваивается NULL и генерируется исключительная ситуация.
lОсвобождение памяти
delete p1;
delete p2;
delete [ ] p3;
Операции с указателями
lразадресация (разыменование)
lприсваивание
lсложение с константой, вычитание константы
lинкремент и декремент
lсравнение
lприведение типа
Разыменование
lОбозначается звездочкой «*»
lПредназначается для доступа к величине, адрес которой хранится в указателе.
lНе допускается с адресами типа void
lМожно использовать как для получения значения, так и для изменения величины
lПримеры использования:
char a; // переменная
char *p = new char; // Выделение динамической памяти
*p = ‘Ю’ ; a = *p; // присваивание значений
Арифметические операции
lАвтоматически учитывают тип указателя.
lИмеют смысл при работе с последовательно размещенными в памяти данными.
char *p1 = (char *)0xAABBCC00;
char * pn = p1 + 1; // pn = 0xAABBCC01;
int *p2 = (int *)0xAABBDD00;
int *pm = p2 + 1; // pm = 0xAABBDD04;
lСложение указателей не допускается
lРазность указателей – разность значений деленная на размер типа в байтах.
Ссылки
lСсылка представляет собой синоним имени, указанного при инициализации.
lОбъявление ссылки: тип & имя;
lПеременная-ссылка должна явно инициализироваться при описании. Кроме случаев:
ссылка является параметром функции
ссылка описана как extern;
lПосле инициализации ссылке не может быть присвоена другая переменная
lТип ссылки должен совпадать с типом величины, на которую она ссылается.
lНе разрешается создавать указатели на ссылки, создавать массивы ссылок и ссылки на ссылки.
lОперации над ссылкой приводят к изменению величины, на которую она ссылается.
Пример использования ссылки
int kol = 5;
int & pal = kol; //pal – альтернативное имя для kol
pal ++; // kol = 6;
Массивы
lОписание одномерного массива –
l тип имя[количество];
lЭлементы массива нумеруются с нуля.
lМогут использоваться модификаторы как для обычных переменных
nКласс памяти
nconst
nинициализатор (инициализирующие значения записываются в фигурных скобках)
lРазмещение массива производится на этапе компиляции, поэтому количество элементов должно быть константой.
lКоличество элементов предпочтительнее задавать с помощью именованных констант поскольку при таком подходе для его изменения достаточно скорректировать значение константы всего лишь в одном месте программы.
Примеры массивов
int m[10];
int N = 100;
double dm[N];
long array[5] = {1,2,3,4,5};
int mas[] = {3,2,1};
int mm[100] = {1,2,3};
Доступ к элементам массивов
Для доступа к элементу массива после его имени указывается номер элемента (индекс) в квадратных скобках.
Например:
int k = mas[i];
Работа с массивом
#include <iostream. h>
int main(){
const int n = 10;
int i, sum;
marks[n] = {3, 4, 5, 4, 4};
for (i = 0, sum =0; i<n; i++)
sum += marks[i];
cout « "Сумма элементов:” « sum;
return 0;
}
Связь массивов и указателей
lИдентификатор массива является константным указателем на его нулевой элемент.
int b[10] –
b и &b[0] – означают одно и то же.
lМожно описать указатель, присвоить ему адрес начала массива и работать с массивом через указатель.
Работа с массивом через указатель
Фрагмент программы копирует массив а в массив b.
int a[100], b[100];
int *ра = а;
int *pb = b;
for(int i = 0: i<100; i++)
*pb++ = *pa++;
Динамические массивы
lДинамические массивы создают с помощью операции new, при этом необходимо указать тип и количество элементов
int n = 100;
float *р = new float [n];
lДинамические массивы нельзя при создании инициализировать, и они не обнуляются.
lПреимущество динамических массивов состоит в том, что размерность может быть переменной, то есть объем памяти, выделяемой под массив, определяется на этане выполнения программы.
lДоступ к элементам динамического массива осуществляется точно так же, как к статическим.
Работа с динамическим массивом
int N = 100;
int *p = new int[N];
for(int i=0;i<N;i++)
p[i] = 0;
…
delete [] p;
Многомерные массивы
lМногомерные массивы задаются указанием каждого измерения в квадратных скобках.
lНапример, оператор int matr [6][8] задает описание двумерного массива из 6 строк и 8 столбцов.
lВ памяти такой массив располагается в последовательных ячейках построчно.
Инициализация многомерного массива
lПри инициализации многомерного массива он представляется:
nкак массив из массивов, при этом каждый массив заключается в свои фигурные скобки (в этом случае левую размерность при описании можно не указывать),
nзадается общий список элементов в том порядке, в котором элементы располагаются в памяти:
lint mass2 [][2] = { {1, 1}, {0, 2}, {1, 0} };
lint mass2 [3][2] = {1, 1, 0, 2, 1, 0}:
Доступ к элементам многомерного массива
lДля доступа к элементу многомерного массива указываются все его индексы.
lНапример,
nmatr[i][j]
n*(matr[i]+j)
n*(*(matr+i)+j)
lЭто возможно, поскольку matr[i] является адресом начала i-й строки массива.
Динамический многомерный массив
int nstr, nstb;
cout «'" Введите количество строк и столбцов :";
cin » nstr » nstb;
int **a = new int *[nstr];
for(int i = 0; i<nstr; i++)
a[i] = new int [nstb];
…
for(int i = 0; i<nstr; i++)
delete [] a[i];
delete[] a;
Размещение динамического массива в памяти
Строки
lСтрока представляет собой массив символов, заканчивающийся нуль-символом.
lНуль-символ — это символ с кодом, равным 0, что записывается в виде управляющей последовательности '\0'.
lПо положению нуль-символа определяется фактическая длина строки.
lСтроку можно инициализировать строковым литералом.
Пример работы со строками
char from[] = “ПЯВУ”;
char to[10];
for(int i=0;i<strlen(from);i++)
to[i] = from[i];
---
for(char *p=from, *t = to;*p!=‘\0’; *t++ = *p++);
С++. Функции
Основные вопросы
lПонятие функции в С++
lОбъявление и определение функции
lВозвращаемое значение и параметры
lФункция main
lФункции форматированного ввода-вывода
Функции в С++
lВ С++ отсутствует понятие процедуры, есть только функции.
lЛюбая программа на С++ состоит из функций.
lОдна из функция должна иметь имя main – с нее начинается выполнение программы.
lЛюбая функция должна быть объявлена и определена. Объявлений может быть несколько, а определение – только одно.
lОбъявление функции должно находиться в теле программы до ее вызова, для того, чтобы компилятор мог проверить его правильность.
lОбъявление функции может находиться в теле другой функции или вне его.
lВ объявлении, определении и при вызове функции типы и порядок следования параметров должны совпадать.
Объявление и определение функции
lОбъявление (прототип, заголовок) функции задает:
§ имя функции
§ тип возвращаемого значения
§ список передаваемых параметров.
lОпределение функции содержит:
§ все что есть в объявлении,
§ тело функции – представляющее собой последовательность операторов и описаний в фигурных скобках.
Структура определения функции
[модификатор] тип имя ([список параметров)
{
тело функции
}
lМодификатор, задающий область видимости функции:
nextern – глобальная видимость – функцию можно использовать во всех модулях программы (устанавливается по умолчанию)
nstatic – видимость только в пределах файла, в котором определена функция.
ninline – рекомендует компилятору заменять вызов функции ее телом.
lТип возвращаемого значения – любой скалярный тип. Если функция не возвращает значений, указывается тип void.
lСписок параметров – состоит из пар типа и имени для каждого параметра. Пары разделяются запятыми.
lВ объявлении функции указывать имя параметров не обязательно. Они используются только для улучшения читаемости программы.
Пример объявления, определения и вызова функции
int sum(int x, int y);
int main(){
int a=2, b=3, c;
с = sum(a, b);
return 0;
}
int sum(int q, int p){
return (q+p);
}
Возвращаемое значение функции
lВозврат значения из функции реализуется с помощью оператора
return [ выражение ];
lТип выражения должен совпадать с типом объявленного возвращаемого значения.
lЕсли функция объявлена как void, return можно не использовать.
lФункция может содержать несколько операторов return.
lНельзя возвращать указатель на локальную переменную, т. к. при возврате из функции память, выделенная под локальную переменную будет освобождена.
Примеры возвращения значений
int f1(){ return 1;}
void f2(){ return 2;} // Ошибка!
double f3(){ return 3;}
int *f4(){
int a = 5;
return &a; // Запрещено!!
}
Действия при вызове функции
lВ стеке выделяется память под
lАдрес возврата функции
lПараметры функции
lВ выделенную под параметры память помещаются значения выражений, указанных при вызове функции в качестве параметров.
lОсуществляется переход по адресу места расположения функции в памяти.
lВ стеке выделяется память для локальных переменных функции.
lВыполняется тело функции
lОсуществляется переход по адресу точки возврата
Параметры функции
lСпособы передачи параметров функции:
nПо значению – в функцию передается копия значения некоторой переменной.
nПо адресу – в функцию передается адрес переменной. В этом случае функция может модифицировать переменную.
Передача параметров по указателю
void sum(int x, int y, int *z);
int main(){
int a=2, b=3, c;
sum(a, b,&c);
return 0;
}
void sum(int q, int p, int *z){
*z = q+p;
}
Размещение указателей в памяти
0x02 |
0xCC |
0xBB |
0xAA |
0x0A |
0x00 |
0x00 |
0x00 |
0x06 |
0xCC |
0xBB |
0xAA |
Запись в программе:
int c = 10;
int *p = &c;
int **pp = &p;
Передача параметров ссылке
void sum(int x, int y, int &z);
int main(){
int a=2, b=3, c;
sum(a, b,c);
return 0;
}
void sum(int q, int p, int &z){
z = q+p;
}
Передача массивов в качестве параметров
lПри необходимости передать в качестве параметра функции массив передается его адрес (адрес его первого элемента)
lЕсли заранее не известно количество элементов в массиве, то оно передается отдельным параметром.
lЕсли передается строка, ее размер можно определить по положению символа с кодом 0.
Пример передачи массива в функцию
int sumMas(int *m, int count);
int main(){
int mm[3] = {1,2,3};
int res = sumMas(mm,3);
return 0;
}
//int sumMas(int mas[],int cnt){
int sumMas(int *mas, int cnt){
int ret = 0;
for(int i=0;i<cnt;i++) ret+=mas[i];
return ret;
}
Параметры со значением по умолчанию
lДля упрощения вызова функции при ее объявлении можно указать значение по умолчанию для параметра.
lРазрешается использование значений по умолчанию только для последних параметров функции.
Пример функций с параметрами по умолчанию
int sumMas(int *m, int count = 3);
int main(){
int mm[3] = {1,2,3};
int res = sumMas(mm);
return 0;
}
//int sumMas(int mas[],int cnt=3){
int sumMas(int *mas, int cnt=3){
int ret = 0;
for(int i=0;i<cnt;i++) ret+=mas[i];
return ret;
}
Функции с переменным числом параметров
lЕсли в объявлении функции список параметров заканчивается многоточием, то это означает, что при ее вызове можно указать еще несколько параметров.
lПроверка этих параметров не выполняется, char и short передаются как int, а float – как double.
lНапример:
int printf(const char *, …);
Пример функции с переменным числом параметров
printf(“ Введите исходные данные”);
printf(“ Итого %10.2f рублей”, sum);
printf(“%i %i %i %i”, a, b, c, d);
Функция main
lФункция, с которой начинается выполнение программы должна иметь имя main.
lВозможны различные определения функции main:
nvoid main()
nint main()
nint main(int argc);
nint main(int argc, char *argv[ ])
lВозвращаемое значение – код возврата программы.
lПараметры – количество аргументов командной строки, и массив указателей на строки, являющиеся аргументами.
Функции форматированного ввода и вывода
lФорматированный вывод на экран – функция printf
lФорматированный ввод с клавиатуры – функция scanf
Форматированный вывод на экран – функция printf
lПрототип:
int printf(char *format,…)
lСтрока формата описывает в каком виде должны быть выведены на экран переменные (значения выражений) следующие после строки формата.
printf(“ Введите исходные данные”);
printf(“ Итого %10.2f рублей”, sum);
printf(“%i %i %i %i”, a, b, c, d);
Спецификатор формата
% [flags] [width] [.prec] [F|N|h|l|L] type_char
lflags – флаги (выравнивание, лидирующие нули и т. д.)
lwidth – минимальное количество символов отводимое под вывод значения
l. prec – точность - количество цифр после запятой для чисел с плавающей точкой
l[F|N|h|l|L] – модификатор типа
ltype_char – тип выводимого значения
Флаги
l - выравнивание по левому краю
l+ Выводить + перед положительными числами и – перед отрицательными
lпробел Выводить пробел перед положительными числами и минус перед отрицательными
Ширина (width)
ln - минимальное количество символов для значения.
nЕсли значение занимает места больше указанного оно будет выведено
целиком,
nЕсли меньше – оставшееся место будет заполнено пробелами.
l0n - оставшееся место будет заполнено нулями
Символ типа
d Integer signed decimal integer
i Integer signed decimal integer
u Integer unsigned decimal integer
x Integer unsigned hexadecimal int (with a, b, c, d, e, f)
X Integer unsigned hexadecimal int (with A, B, C, D, E, F)
f Floating point signed value of the form [-]dddd. dddd.
e Floating point signed value of the form [-]d. dddd or e[+/-]ddd
g Floating point signed value in either e or f form, based on given value and precision. Trailing zeros and the decimal point are printed if necessary.
E Floating point Same as e; with E for exponent.
G Floating point Same as g; with E for exponent if e format used
c Character Single character
s String pointer Prints characters until a null-terminator is pressed or precision is reached
% None Prints the % character
Форматированный ввод с клавиатуры – функция scanf
lПрототип –
int scanf(char *format,…)
lСтрока формата описывает как должны интерпретироваться вводимые значения
lПараметры после строки формата должны содержать адрес переменной, в которую будет помещено считанное значение.
int a, b,c, d;
scanf(“%i %i %i %i”, &a, &b, &c, &d);
С++.
Дополнительные возможности
Основные вопросы
lПрограммы из нескольких модулей
lФайловый ввод-вывод
lСтандартные функции
nМатематические функции
nФункции работы со строками
lДинамические структуры данных
nмассивы с динамически изменяемым размером
nсписки
nструктуры данных на основе списков
Программы из нескольких модулей
lПонятие модуля эквивалентно понятию пакета.
lИспользование модулей упрощает повторное использование кода.
lВ модуль помещается набор функций – файл имеет расширение. cpp. Объявление функций помещается в файл с таким же именем и расширением. h.
lДля включения описания функций используется директива препроцессора
n#include <имя файла с описаниями> - поиск данной библиотеки в системных папках
n#include “имя файла с описаниями” - поиск данной библиотеки в папке проекта
Структура программы из нескольких модулей
Пример программы из двух модулей
lМодули
nГлавный модуль (main. cpp)
nМодуль с функциями
lФайл с объявлением функций (funcs. cpp)
lФайл с определением функций (funcs. h)
funcs.h
/* Описание действий, производимых функцией, возвращаемого значения, параметров */
void f1();
/* Описание действий, производимых функцией, возвращаемого значения, параметров */
int f2();
/* Описание действий, производимых функцией, возвращаемого значения, параметров */
char * f3(int a, int b);
/* Зачем нужна переменная */
extern int GlobalData;
funcs.cpp
/* Описание действий, производимых функцией, возвращаемого значения, параметров */
|
Из за большого объема этот материал размещен на нескольких страницах:
1 2 3 4 5 6 7 |
