Функция стандартного ввода scanf():
Функция scanf() - функция форматированного ввода. С её помощью вы можете вводить данные со стандартного устройства ввода (клавиатуры). Вводимыми данными могут быть целые числа, числа с плавающей запятой, символы, строки и указатели.
Спецификаторы формата:
%c |
чтение символа |
%d |
чтение десятичного целого |
%i |
чтение десятичного целого |
%e |
чтение числа типа float (плавающая запятая) |
%o |
чтение восьмеричного числа |
%s |
чтение строки |
%x |
чтение шестнадцатеричного числа |
%p |
чтение указателя |
Пример программы:
/* Пример 1 */ #include <stdio.h> void main(void) { int age; printf("\nСколько вам лет?:"); scanf("%d",&age); printf("Вам %d лет.", age); }
Наследование:
Наследование - отношение, которое определяет одну сущность в терминах другой. В случае наследования класса новый класс определяется в терминах одного или нескольких родительских классов. Новый класс наследует интерфейс и реализацию от своих родителей. Новый класс называется подклассом или производным классом (в C++).
Наследование класса объединяет наследование интерфейса
и наследование реализации. В случае наследования интерфейса новый интерфейс определяется в терминах одного или нескольких существующих. При наследовании реализации новая реализация определяется в терминах одной или нескольких существующих.
ПРОСТОЕ НАСЛЕДОВАНИЕ
Наследование представляет собой способность производного класса наследовать характеристики существующего базового класса. Например, предположим, что у вас есть базовый класс employee:
class employee
{ public: employee(char *, char *, float); void show_employee(void); private: char name[64]; char position[64]; float salary; };
Далее предположим, что вашей программе требуется класс manager, который добавляет следующие элементы данных в класс employee:
float annual_bonus; char company_car[64]; int stock_options;
В данном случае ваша программа может выбрать два варианта: во-первых, программа может создать новый класс manager, который дублирует многие элементы класса employee, или программа может породить класс типа manager из базового класса employee. Порождая класс manager из существующего класса employee, вы снижаете объем требуемого программирования и исключаете дублирование кода внутри вашей программы.
Для определения этого класса вы должны указать ключевое слово class, имя manager, следующее за ним двоеточие и имя employee, как показано ниже:
Производный класс //-----> class manager : public employee { <-------// Базовый класс
// Здесь определяются элементы };
Ключевое слово public, которое предваряет имя класса employee, указывает, что общие (public) элементы класса employee также являются общими и в классе manager. Например, следующие операторы порождают класс manager.
class manager : public employee
{ public: manager(char *, char *, char *, float, float, int); void show_manager(void); private: float annual_bonus; char company_car[64]; int stock_options; };
Что следует знать:
Наследование представляет собой способность производить новый класс из существующего базового класса.
Производный класс — это новый класс, а базовый класс — существующий класс.
Когда вы порождаете один класс из другого (базового класса), производный класс наследует элементы базового класса.
Для порождения класса из базового начинайте определение производного класса ключевым словом class, за которым следует имя класса, двоеточие и имя базового класса, например class dalmatian: dog.
Мно́жественное насле́дование — свойство, поддерживаемое частью объектно-ориентированных языков программирования, когда класс может иметь более одного суперкласса (непосредственного класса-родителя). Эта концепция является расширением «простого (или одиночного) наследования» (англ. single inheritance), при котором класс может наследоваться только от одного суперкласса.
Предположим, к примеру, у вас есть класс computer_screen:
class computer_screen
{ public: computer_screen(char *, long, int, int); void show_screen(void); private: char type[32] ; long colors; int x_resolution; int y_resolution; };
Предположим, что у вас есть также класс mother_board:
class mother_board
{ public: mother_board(int, int, int); void show_mother_board(void); private: int processor; int speed; int RAM; };
Используя эти два класса, можно породить класс computer, что показано ниже:
class computer : public computer_screen, public mother_board
{ public: computer(char *, int, float, char *, long, int, int, int, int, int); void show_computer(void); private: char name[64]; int hard_disk; float floppy; };
Как видите, этот класс указывает свои базовые классы сразу после двоеточия, следующего за именем класса computer.
class computer : public computer_screen, public mother_board //——————> Базовые классы
Алгоритм ветвления в C++
Встречаются ситуации, когда программе нужно выбрать, какую операцию ей выполнить, в зависимости от определенного условия.
К примеру, мы вводим с клавиатуры целое число. Если это число больше десяти, то программа должна выполнить одно действие, иначе — другое. Реализуем этот алгоритм на C++ с помощью конструкции ветвления, используя оператор if.
Внешний вид программы:
У нас имеются следующие компоненты: Label1 для вывода результата, Edit1 для считывания числа, которое введет пользователь и Button1 для выполнения операции сравнения.
Для сравнения используется операторы if и else. Общий вид:
if (выражение1) {
оператор1; }
else {
оператор2;}
Как это будет выглядеть в нашем случае:
int x = 10; //объявляем переменную, с которой будем сравнивать
int y = StrToInt(Edit1->Text);
//во вторую переменную такого же типа извлекаем число из Edit1, повторяем перевод типов и переводим строчку в число StrToInt()
if (y>=x) {
Label1->Caption="Это число больше, либо равно 10";}
else {
Label1->Caption="Это число меньше десяти";}
И в конце выводим результат пользователю в Label 1:
Эту же самую программу можно выполнить при помощи конструкции switch-case. Синтаксис это конструкции:
switch ( <переменная> ) {
case значение1:
Выполнить если <переменная> == значение1
break;
case значение2:
Выполнить если <переменная> == значение2
break;
...
default:
выполнить, если ни один вариант не подошел
break;
}
Как это будет выглядеть в случае нашей программы:
int x = 10;
int y = StrToInt(Edit1->Text);
switch (y) {
case 1:
Label1->Caption="Число равно 1";
break;
case 2:
Label1->Caption="Число равно 2";
break;
. . . . . . . . . . . .
case 10:
Label1->Caption="Число равно 10";
break;
default:
Label1->Caption="Число больше 10"; }
Обязательно не забываем после каждого case приписывать break, иначе программа начнет выводить все те значения, которые идут после верного совпадения. Т.е. если мы после всех case забыли break и ввели число пять, то программа выведет следующий результат:
Число равно 5
Число равно 6
Число равно 7
Число равно 8
Число равно 9
Число равно 10
Число больше 10
Так что будем внимательны, используя эту конструкцию.
Цикл for в C++
Цикл — многократное прохождение по одному и тому же коду программы. Циклы необходимы программисту для многократного выполнения одного и того же кода, пока истинно какое-то условие. Если условие всегда истинно, то такой цикл называется бесконечным, у такого цикла нет точки выхода.
В языке программирования С++ существуют такие циклы:
цикл for
цикл while
цикл do while
Но по большому счету циклом for можно заменить оставшиеся два.
Тело цикла будет выполняться до тех пор, пока условие будет истинно(т. е. true).
|
// форма записи оператора цикла for:
for (/*выражение1*/; /*выражение2*/; /*выражение3*/ ) { /*один оператор или блок операторов*/; } Где выражение1 – это начальное условие, выражение2 – условие выхода из цикла, Выражение3 – что мы делаем, пока не выйдем из цикла. |
Напишем программу, которая выведет нам в Memo1 числа от одного до десяти. Можно просто каждой отдельной строчкой прописать Memo1->Lines->Add(“тут будет число от 1 до 10”), но это будет целых 10 строчек кода, а если нам нужно вывести числа от 1 до 100, то нам придется слишком много раз копипастить, что не есть удобно. И вот тут нам на помощь и проходят циклы.
for (int i = 1; i = 100; i++) {
Memo1->Lines->Add(i);
}
Вот так с помощью всего двух строчек кода мы сможем вывести числа от 1 до 100.
Int i = 1 – это у нас начальное условие.
i = 100 – это условие выхода из цикла, т.е. как только i будет равно 100, то мы выйдем из цикла.
i++ - с каждым выполнением цикла, мы будем увеличивать i на единицу.