Программирование на языке С++

1.

Программирование на языке С++
Лекция 2
ЗАГОЛОВОК
• Массивы и циклы
• Структуры и функции
• Оператор выбора
ПРЕЗЕНТАЦИИ
• Основы ООП
подзаголовок
Составил Заворотыло В.Н., ДЦЭ, доцент, 2021г.

2. Массивы

Массив – это совокупность однотипных переменных. Имеет общее имя и состоит из
элементов. Каждый элемент имеет индекс (номер). В С нумерация элементов массива
начинается с 0.
Array
значения
20
индекс
0
5
1
-11
2
2
3
0
4
21
-13
18
5
6
7
6
8
-6
9
Объявление массива:
<тип> <имя>[[<число элементов>]] [=<инициализатор>];
<тип> - тип элементов, любой допустимый в С, в т.ч. массив
<имя> - имя массива – идентификатор
[<число элементов>] - константное выражение в квадратных скобках, задающее число
элементов в массиве. В некоторых случаях необязательно.
Пример:
int array[10];
char cmassiv [1000];
float arrf1[5], arrf2[2*5];
//массив целых чисел из 10 элементов.
//массив символов из 1000 элементов
// два массива ЧПТ 5 и 10 элементов.
•2

3. Массивы

<инициализатор> - имеет вид {<список значений>} и задает начальные значения элементов .
int iarr[5]={1,2,3,4,5};
// массив целых чисел с инициализацией
int ia1[10]={0};
// очистка массива
int ia2[]={10,20,30,40}
// массив целых чисел из четырех элементов
Символьные массивы можно инициализировать строками. Строка это текст с двоичным нулем в
конце.
char car1[]=”Borland”;
// символьный массив из 8 элементов: B,o,r,l,a,n,d,0
char car2[]={‘B’, ’o’, ’r’, ’l’, ’a’, ’n’, ’d’};
// массив из 7 элементов: B,o,r,l,a,n,d
char car3[10]=”Borland”;
// массив из 10 элементов: B,o,r,l,a,n,d,0,0,0
char car4[4] =”Borland”;
// массив из 4 элементов: B,o,r,l
Многомерные массивы.
Элементом массива в свою очередь может быть массив. Такие массивы называются
многомерным. Пример двумерного массива с инициализацией:
int TwoDimArray[3][4] = {{0,1,2,3}, {4,5,6,7}, {8,9,10,11}};
0
1
2
3
4
5
6
7
8
9
10
11
Этот массив можно представить как массив из трех целочисленных массивов по 4 элемента в
каждом. Наглядно этот массив можно представлять как матрицу из трех столбцов по 4 элемента в
каждом.
•3

4. Операции с массивами

К массиву в целом можно применить операцию sizeof <имя>, которая возвращает длину массива
В остальном работа с массивами выполняется поэлементно. Обращение к элементу массива имеет
вид:
<имя>[<индекс>]
С элементом можно обращаться как с переменной соответствующего типа.
{
int x, y, array[5]={1,2,3,4,5};
x=array[0];
// x=1
y=array[4]+1;
// y =6
array[2]=x+y;
// третий элемент = 7
array[0]++;
// первый элемент = 2
const unsigned ArrN=20;
float farr[ArrN];
int i;
// выводим содержимое массива
for (i=0; i<ArrN; i++) cout<<array[i]<<’ ‘;
// в строку
// выводим в обратном порядке
for (i= ArrN-1; i>=0; i--) cout<<array[i]<<endl;
// в столбик
// символьный массив
char str[12]=”Borland C++”;
cout<<str;
// выводим строку
for (i=0;i<sizeof str; i++) cout<<str[i];
// посимвольно
}
•4

5. Операторы повторения

• Операторы повторения обеспечивают повторение группы
операторов. Именно возможность многократного повторения одних
и тех же действий позволяет компьютерам выполнять огромные
объемы вычислений, непосильных человеку.
• В С++ имеются три оператора повторений. Первый их них имеет
формат:
• for ([<нач. выражение>];[<условие продолжения >];[<выражение
продвижения>])<оператор>
• Алгоритм выполнения повторов следующий:
• Выполняется <начальное выражение>. Оно выполняется один раз
перед всеми повторами и обычно задает подготовительные
действия.
• Проверяется <условие продолжения>. Это условие представляет
собой выражение, результат которого трактуется как логический.
Если выражение не равно нулю (в С.С++ это истина), повторы
продолжаются, если равно (ложь), происходит выход из цикла на
оператор, следующий после for.
• Если <условие продолжения> истинно, выполняется <оператор>,
затем <выражение продвижения> и начинается следующий цикл с
проверки <условия продолжения>.

6. Операторы повторения

• Оператор for применяют со счетчиком циклов – целочисленной переменной, в которой
хранится число выполненных циклов:
• int i;
//счетчик циклов
• for (i=0;i<100;i++) cout<<i*i); // выводим на экран квадраты чисел от 0 до 99
• Есть операторы, которые могут применяться только в теле операторов повторения:
• continue;
- переход на следующую итерацию (цикл)
• break;
- выход из оператора повторения
• Например, если мы хотим вывести только четные числа в диапазоне от 0 до 100, оператор
может выглядеть следующим образом:
• for(i=0 ; ; i++)
// условие продолжения всегда «ИСТИНА»
• { if (i==100) break;
// достигли предела - выход
if (i%2!=0) continue;
// нечетное число – на следующий цикл
cout<<i;
// выводим
• }

7. Операторы повторения

• Следующий оператор повторения имеет вид:
• while (<условие продолжения>)<оператор>
• Здесь while – ключевое слово, далее в скобках <условие
продолжения>, затем повторяемый <оператор> (один,
обязательный).
• while (i<100) cout<<i++;
• Последний оператор повторения имеет вид:
• do <оператор> while (<условие продолжения>);
• Отличия от предыдущих операторов в том, что условие
продолжения проверяется после оператора. Т.е. здесь
оператор выполнится хотя бы один раз. Поэтому оператор do
называется оператором с пост-условием, в отличие от
операторов for и while, которые называются операторами с
предусловием. Это бывает важным при программировании.
• do cout<<i; while (i++<100);

8. Указатели

Указатели – переменные, значением которых, является адрес поля в оперативной памяти
<тип> * <идентификатор> ;
int x, * pi;
// указатель pi на тип int
Операции с указателями
& -- адрес переменной
*
-- разыменование
x=5;
pi=&x;
*pi=7;
x,адрес=1000
0
5
pi
// pi указывает на x
// записать в x значение 7
1000
Адресная арифметика
Однотипные указатели можно вычитать друг из друга. Результат – число элементов типа указателя.
int *pi1=1000, *pi2=1012, x;
x=pi2-pi1; // x==3, 3 элемента типа int длиной 4 байта
Указатель можно сложить с целым числом. Результат – адрес, на число элементов типа указателя
больший исходного.
Если pi=1008, то pi+3 = 1020, т.к. длина переменной типа int=4.
То же относится к вычитанию целого числа из указателя.
8

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

Массив это константный указатель на начало массива, на его первый элемент.
int arr[10];
arr[i] *(arr+i) *(i+arr) i[arr]
// arr – указатель типа int
// обращения к i-тому элементу
Копирование строк
char c1[100]=“Microsoft ”, c2[100], *p1, *p2 ;
p1=c1; p2=c2;
while(p2++ = p1++);
9

10. Указатели и динамическая память

Динамическая память, это память не занятая программами. Может выделяться программе по
запросу.
ОП
ОС
Запрос памяти - оператор new
<указатель> = new <тип> [<количество>];
программа
int * pi;
pi=new int;
// запрос элемента
if (pi==null) cout<<“Нет памяти”;
динамическая
память
////
pi=new int [100]; // запрос массива
for(i=0; i<100; i++) pi[i]=i;
Освобождение памяти – оператор delete
delete <указатель>;
delete pi;
ОС
10

11. Оператор выбора

• Оператор выбора switch позволяет разделить программу
на произвольное число ветвей.
switch (<ключ выбора>)
{
case <ключ варианта 1>: [<операторы 1>]
case <ключ варианта 2>: [<операторы 2>]
...
case <ключ варианта n>: [<операторы n>]
[default:<операторы 0>]
}
• <ключ выбора> сравнивается с ключами вариантов.
• Если есть совпадение, выполняются операторы варианта
и все операторы до конца блока.
• Если нет совпадений, выполняются операторы варианта
default, если он задан.
• Для досрочного выхода из варианта в операторе switch
можно использовать оператор разрыва break.

12. Структуры

• Структуры – это совокупность разнотипных переменных. Имеет общее имя и состоит из
полей. Каждое поле имеет свое имя (идентификатор). В памяти поля размещаются друг за
другом.
• Объявление структуры
• Формат 1 (полный):
• struct [<тег>] {<объявления полей>} [<список описателей>];
• <тег> - идентификатор типа
• <объявление поля> - имеет формат объявления соответствующего типа данных, отличие
лишь в отсутствии инициализаторов. Инициализировать можно переменную в целом.
• Пример – комплексное число:
• struct CompleX
// тег = Complex
• {
float Re;
// два поля
float Im;
// типа ЧПТ
• };
// без описателей

13. Структуры

• Формат 2 (дополнительный). Используется при наличии
объявления по формату 1.
• <тег> <список описателей>;
• Пример:
• CompleX c, cc={1.5, 3.14};
//две переменные,
//одна инициализирована
• Обращение к полю структуры:
• <переменная>.<поле>
• c.Re=2.;
• cc=c;
c.Im=.5;
//однотипные структуры можно
//присваивать друг другу

14.

Структуры - пример
•Сложение комплексных чисел
14

15.

Функции
•С-программа состоит из функций. Должна быть одна функция с именем main и
произвольное число неглавных функций, определенных пользователем.
•Функция – это часть программы, вызываемая по имени. В функцию можно
передавать параметры. В ответ функция может вернуть некоторое значение (одно),
содержащее или результат функции или признак её выполнения.
•Чтобы построить свою функцию, её нужно определить. Формат определения
функции имеет вид:
•<тип> <имя> (<список параметров>)
•{<объявления> <операторы>}
•<тип> - задает тип возвращаемого значения
•Параметр задается в виде <тип> <имя>
15
// заголовок
// блок

16.

Функции
•Пример функции, возвращающей большее из двух чисел
•int max (int x, int y)
•{
• if(x>y) return x;
• else return y;
•}
•Функция называется max, имеет два формальных параметра x и
y
целого типа.
•На выходе возвращает целое число (int). Возврат выполняется оператором
return;
16

17.

Функции
•В программе функция вызывается по имени с заданием фактических параметров.
Возвращаемое значение используется в дальнейших вычислениях.
•int max (int x, int y)
//функция пользователя
•{ if(x>y) return x; else return y;}
•///////////////////////////////////////////////////////////
•int main ()
//основная функция
•{ int a=10, b=20, z;
• z=max(a,b);
// вызов
• z=max (a+2, b*b);
// вызов
• cout<< max(z-a, z+b); // можно так!
• return 0;
•}
17

18.

Функции
•Если функция определена после вызова, то до вызова ее надо объявить
•int max (int x, int y);
//объявление функции
•////////////////////////////////////////////////////////////////////////////////////////////
•int main ()
•{ int a=10, b=20, z;
• z=max(a,b);
• …
• return 0;
•}
//основная функция
// вызов
•//////////////////////////////////////////////////////////////////////////////////
•int max (int x, int y)
//функция пользователя
•{ if(x>y) return x; else return y;}
18

19. Язык С++

С++ разработан в начале 80-х годов в той
же «Bell Laboratories» для реализации
объектно-ориентированного
программирования.
Автор Бьярн Страуструп.
С++ на языке С означает С на единицу
большее. Название придумал Рик
Маситти (Rick Mascitti).
C++ включает С как подмножество.
19
Бьёрн Страуструп (дат. Bjarne Stroustrup);
род. 30 декабря 1950, Орхус, Дания) —
программист,
автор языка программирования C++.

20. Состав класса

Основные понятия ООП – это класс и объект.
Соотносятся как тип и переменная.
Т.е. класс это описание будущих объектов,
объект – конкретный экземпляр класса, размещенный в памяти.
Класс состоит из членов (members).
Бывают члены-данные – свойства (properties)
и члены-функции – методы доступа (access methods).
Членам задают уровень доступа:
public:
- общедоступный;
private:
- доступный только в классе;
protected:
- доступный в классе и классах-наследниках;
20

21. Объявление класса

Объявление класса имеет вид
сlass | struct
<имя класса>
{ описание членов };
По умолчанию: если задано struct – члены имеют доступ public.
Если class - private.
Пример класса «Счетчик». Класс имеет свойство: число событий, и методы:
обнуление счетчика, продвижение счетчика, сообщение текущего состояния.
21

22. Объявление объекта

Объявление объекта имеет вид
<имя класса> <описатели объектов>;
Пример:
Counter c;
22
// с - объект класса «Счетчик»

23. Работа с объектом

Подсчет числа цифр в тексте
23

24. Конструкторы и деструкторы

В состав класса можно включать специальные методы: конструкторы и
деструкторы.
Конструктор – метод, который автоматически запускается в момент создания
объекта.
Для конструктора тип не указывается, имя конструктора совпадает с именем
класса. Может иметь параметры, следовательно, может перегружаться, т.е.
конструкторов может быть несколько.
Назначение конструктора – подготовить объект к работе, обычно – задать
начальные значения свойств.
Т.е. конструктор объекта – это аналог инициализации переменных.
Пример конструктора для класса «Счетчик»:
Counter () {count=0;} // задает начальное значение свойства count = 0
24

25. Конструкторы и деструкторы

Деструктор – метод, который автоматически запускается в момент
уничтожения объекта.
Для деструктора тип не указывается, имя деструктора совпадает с именем
класса со знаком ‘~’ (тильда) вначале. Параметров не имеет, следовательно,
деструктор в классе может быть один.
Назначение конструктора – завершающие действия после работы в объектом.
Пример деструктора для класса «Счетчик»:
~Counter () {}
25
// ничего не делает

26. Класс «Счетчик»

26

27. Дружественные функции

Дружественные функции – это обычные функции, которые имеют доступ к
закрытым членам класса. Обычно применятся для программирования
взаимодействия между объектами.
27

28. Сложение комплексных чисел

28

29. СПАСИБО ЗА ВНИМАНИЕ!

29