- •1.1. Что такое программа и как она выглядит?
- •1.2. Комментарии
- •1.3. Зарезервированные слова и типы данных
- •1.4. Объявление переменных
- •1.5. Операции и выражения
- •1.6. Ввод и вывод
- •1.7. Переменные и константы
- •1.8 Логические операторы
- •1.9. Управляющие операторы
- •1.10. Операторы циклов
- •1.11. Операторы перехода
- •2. Функции
- •2.1. Передача параметров
- •2.2. Библиотечные функции
- •2.3. Локальные и глобальные переменные
- •Объявления функций
- •Время жизни и область видимости программных объектов
- •Int local_var; /* по умолчанию auto */
- •2.4. Перегрузка
- •3. Массивы
- •4. Структуры
- •Int numberPeriod; //число переодов начисления процентов
- •Int page; //Количество страниц
- •Void print(); /*Внимание, записывается только прототип функции */
- •Int yearBorn; //год рождения
- •Int yearBorn; //год рождения
- •4.1. Демонстрационные программы
- •Int done;/*переменная, которая информирует о конце списка файлов */
- •6. Объединения
- •Info;//Обявление переменной типа объединение
- •Info;//Обявление переменной типа объединение
- •7. Объектно-ориентированное программирование
- •7.1. Классы и объекты
- •Демонстрационные программы
- •Результат работы программы
- •7.2. Конструкторы и деструкторы
- •Конструктор копирования
- •7.5. Наследование
- •7.3. Создание объектов и обращение к членам объекта
- •8. Абстрактные типы данных
- •9. Пространство имен
- •Void greeting();/*это пространство имен содержит функцию с тем же именем*/
- •Void big_greeting(); /*эта функция не попадает ни в одно из созданных подпространств,т.Е. Принадлежит пространству имен std */
- •//Определение функций
- •Void big_greeting() /* определение данной функции не принадлежит ни одному из созданных пространств имен, следовательно дальнейший код помещается в глобальное пространство имен */
- •10. Строки
- •4.3 Демонстрационные программы
- •4.10. Класс string
- •Класс AnsiString
- •Класс AnsiString
- •Класс Set
- •4.9. Перегрузка операторов
- •Использование "умных" указателей
- •4.8. Полиморфизм
- •Главное меню — компонент MainMenu
- •Диалоги
- •Файлы и потоки
- •Ввод-вывод в файл
- •Ifstream inStream; //Объявление входного потока
- •InStream.Open("character.Dat"); /*присоединение файла к входному потоку */
- •InStream.Close(); //закрытие входного потока
- •If(!out){ //при неудачной попытке
- •If(in.Fail()){ //поток не создан, то сообщение и выход
- •Управление потоком ввода-вывода
- •5.2. Ввод имен файлов
- •5.3. Манипуляторы
- •5. Указатели
- •5.1.Типы указателей и операции с указателями
- •Адресная арифметика
- •Сравнение указателей
- •Преобразование типа указателя
- •Указатель void
- •5.2. Динамические массивы
- •Int array[10]; //объявляется массив с именем array
- •Int a[10]; //объявляется массив с именем a
- •Int *array1; //указатель типа int с именем array1
- •Int *array[5];/*массив с именем array, его элементы указатели*/
- •Int (*point)[4][5]; /*объявление указателя на двумерный массив без имени */
- •Использование указателей в функциях и указатели на функции
- •Указатель классов
- •Шаблоны
- •Шаблоны функций
- •Void Swap (t& X, t& y) /* к моменту обращения тип т будет известен и заменен, например, на int */
- •Void sort(t array[], int maxIndex){ /*передали массив и его размер */
- •6.2. Шаблоны классов
- •6.3 Демонстрационные программы
- •7.1 Обработка исключений
- •Исключения и их стандартная обработка
- •Базовый класс исключений vcl Exception
- •Упражнения
- •Обработка исключительных ситуаций, возбуждаемых оператором new
- •Исходные файлы и объявление переменных
- •Связаные списки
- •Void newHead( //прототип функции создающей узел
- •Void newHead(//прототип функции создания узла
- •Поиск в связанных списках
- •Void newHead(PtrNode& head, //адрес головного узла
- •Директивы препроцессора.
- •Структура файла проекта
- •Структура make-файла
- •Структура модуля
- •Структура h-файла
- •Файл формы
- •Особенности программирования под Windows.
- •Функция WinMain
- •Создание проекта Win32Application.
- •Библиотека mfc.
- •Создаем код
- •Шпаргалка
- •Структура файла проекта
- •Структура make-файла
- •Структура модуля
- •Структура h-файла
- •Файл формы
- •Файл проекта
- •Введение
- •Свойства компонентов
- •События
- •Менеджер проектов
- •Пример: создание простейшего приложения
- •Графика Внедрение картинок
- •Редактор изображений
- •Классы для хранения графических объектов.
- •If (SelectDirectory( //Компонент библиотеки
- •Методы создания собственной графики. Рисование по пикселам
- •Int px, py; //координаты пикселей
- •Рисование с помощью пера
- •Int px, py; //координаты пикселей
- •Рисование кистью
- •Мультимедиа и анимация Общие сведения о звуковых и видеофайлах
- •Способы воспроизведения звуков
- •Создание мультфильма
- •Воспроизведение немых видео клипов — компонент Animate
- •Проигрыватель MediaPlayer
- •Процессы, потоки, распределенные приложения
- •If include "uOverlayl.H" // включение головного файла приложения
- •Функция CreateProcess
- •490 _ Глава 7
- •7.8.4 Элементы ActiveX
- •492 Глава 7
- •494 Глава 7
- •7.9 Компоненты-серверы сом
- •496 Глава 7
- •7.9.2 Свойства и методы сервера Word
- •500 Глава 7
- •Заключение
- •Что такое ansi?
- •Почему вместо русских букв в консольном приложении выводится мусор? Автор: Алексей Кирюшкин Версия текста: 1.0
- •Раздел I.2Выход 1
- •Раздел I.3Выход 2
- •Раздел I.4Выход 3
- •Раздел I.5Выход 4
- •(A)Потоки
- •(C)Ввод-вывод файлов
- •Выбор компонентов для групповых операций
- •Установка разделяемых свойств компонентов
- •Изменение размера компонентов
- •Выравнивание компонентов
- •Пример: Создание текстового редактора Проектирование формы приложения
- •Создание обработчиков событий
- •Создание меню
Конструктор копирования
При создании программ для переменных базовых типов часто приходится писать оператор присваивания
a=b;
То же самое приходится делать и для объектов создаваемых классов. В следующем примере создается класс, который имеет две переменные и одну функцию (если не считать конструктора), которая находит сумму указанных переменных.
#include<iostream.h>
class myClass{
public:
int x,y;
myClass(int x, int y){
myClass::x=x; myClass::y=y;
}
void sum();
};
void myClass::sum(){cout<<"Summa"<<x<<"+"<<y<<"="<<x+y<<endl;
}
В функции main создается два объекта этого класса, причем один инициализируется с помощью конструктора, другой путем присвоения значения первого обекта.
void main(){
myClass mc1=myClass(1,2);
myClass mc2=mc1;
mc2.sum();
mc1.~myClass();
mc2.sum();
}
В данном случае создается побитовая копия объекта mc1
Если теперь с помощью деструктора уничтожить объект mc1, то все равно второй объект mc2 останется.
Этот пример говорит о том, что объект mc2 это не ссылка на ранее созданный объект. Для mc2 в памяти выделено специальное место. Освободив память под mc1 мы, тем не менее, оставили в памяти точно такой код или, говоря иначе, копию под именем mc2.
Копирование можно выполнить иначе. Для этого добавим еще один конструктор в котором создается объект ранее созданного класса
myClass(myClass &m){/*m- формальное обозначение объекта
* класса myClass */
myClass::x=m.x; myClass::y=m.y;
}
В функции main теперь можно копировать объекты иначе
7.5. Наследование
Мы как то уже говорили, что классы обладают несколькими важными свойствами и даже назвали одно из них – это инкапсуляция. Рассмотрим еще два важных свойства – наследование и полиморфизм.
Наследование – процесс благодаря которому новый класс, который называется производным, создается на основе другого класса, именуемого базовым. Производный класс автоматически обладает всеми переменными и функциями-членами базового класса, а также может дополнительно иметь свои переменные и функции.
Идея наследования появилась сразу как только программирование перестало быть уделом ученых-одиночек, разрабатывающих вычислительные машины. Примерно в 60 годы прошлого века программирование стало доступно инженерам, которые смогли начать решать свои прикладные задачи. Работая в своей научной области, каждый программист решал похожие задачи. Вероятно большинство программистов, подходя к решению очередной задачи вспоминали о своих предыдущих программах и включали их полностью или частично в новый код. В итоге новая программа наследовала многие черты предыдущих программ. Конечно, из-за отсутствия средств автоматизации такая технология оставалась достаточно непродуктивной. Ведь нужно помнить многие предыдущие программы, их алгоритмы, не перепутать обозначения переменных, нужно что то выбросить и что то добавить. Поэтому идея наследования свойств одной программы – родителя другой программой – потомком витала в умах многих программистов. Правда, от идеи до её реального воплощения был путь в несколько десятков лет.
Конечно, хочется побыстрее узнать как создать производный класс, или как еще приято говорить дочерний класс или класс потомок. Делается это довольно просто. Рассмотрим в качестве примера создание программы калькулятора. Давайте сначала создадим какой-нибудь базовый или родительский класс или класс предок. Пусть, например, это будет класс summator, который вычисляет сумму двух чисел.
class summator{
public:
double sum(double x, double y);
double diff(double x, double y);
};
double summator::sum(double x, double y){
return (x+y);
}
double summator::diff(double x, double y){
return (x-y);
}
Класс summator умеет только складывать и вычитать. Создадим дочерний класс calculator, который наследует функции сложения и вычитания двух чисел и, кроме того, умеет умножать и делить.
class calculator : public summator{
public:
double mult(double x, double y);
double div(double x, double y);
};
double calculator::mult(double x, double y){
return x*y;
}
double calculator::div(double x, double y){
return x/y;
}
Для того, чтобы использовать класс calculator нужно ввести числа и вывести результат. Поэтому создадим еще один класс для ввода-вывода, который наследует все функции класса calculator.
#include <iostream>
using namespace std;
class input_output : public calculator{
public:
double x, y, z;
char sign;
input_output();
};
input_output::input_output(){
cout<<"x=";
cin>>x;
cout<<"y=";
cin>>y;
cout<<"sign ";
cin>>sign;
switch (sign){
case '+': z= sum(x,y); break;
case '-': z= diff(x,y); break;
case '*': z= mult(x,y); break;
case '/': z= div(x,y); break;
default: cout << "\nThe program is over";
}
cout<<"result="<<z<<endl<<endl;
}
Класс input_output умеет ввести числа и вывести на экран результат. Кроме того, от созданных ранее классов он унаследовал функции арифметических действий. Теперь создадим обычную программу с функцией main в которой инициализируем объект io, как объект класса input_output. Иначе говоря запустим программу которая умеет ввести два числа, знак арифметической операции, вычислить результат этой операции и вывести его на экран.
void main(){
input_output io;//объявление объекта
io=input_output();//инициализация с помощью конструктора
}
Стандартом ANSI предусмотрена инициализация неявным вызовом, т.е функция main должна бы иметь вид
void main(){
input_output io();
}
однако в среде Borland C++ эта возможность не поддерживается, но возможна инициализация подобная для базовых типов
void main(){
input_output io=input_output();
}
Вероятно вы уже поняли, что класс потомок создается по следующему правилу
class имя_класса_потомка : public имя_класса_родителя
{
объявление переменных и функций
};
описание функций.
Язык С++ позволяет производить наследование одновременно от нескольких классов. Так в рассмотренном выше примере вместо того, чтобы последовательно наследовать свойства от одного класса к другому можно сразу произвести наследование двух классов
class input_output : public calculator, summator{
. . .
}
Наследование производится просто перечислением наследуемых классов через запятую. Иллюстрацией сказанному является следующий рисунок.
Рис. Последовательное и одновременное наследование классов.
Наследование это мощный инструмент программирования. Однако нужно помнить, что создавая класс можно унаследовать противоречивые свойства, что в конечном итоге приведет к ошибкам в работе программы.
Конструкторы и деструкторы
Если у базового и у производного классов имеются конструкторы и деструкторы, то конструкторы выполняются в порядке наследования, а деструкторы — в обратном порядке. Таким образом, конструктор базового выполняется раньше конструктора производного класса. Для деструкторов правилен обратный порядок: деструктор производного класса выполняется раньше деструктора базового класса.
Последовательность выполнения конструкторов и деструкторов достаточно очевидна. Поскольку базовый класс "не знает" о существовании производного, любая инициализация выполняется в нем независимо от производного класса и возможно становится основой для любой инициализации, выполняемой в производном классе. Поэтому инициализация в базовом должна выполняться первой.
С другой стороны, деструктор производного класса должен выполни раньше деструктора базового класса потому, что базовый класс лежит основе производного. Если бы деструктор базового класса выполнялся первым, это бы разрушило производный класс. Таким образом, деструктор производного класса должен вызываться до того, как объект прекратит существование.
Пока что ни в одном из предыдущих примеров мы не передавали аргументы для конструктора производного или базового класса. Однако это вполне возможно. Когда инициализация проводится только в производном классе аргументы передаются обычным образом. Однако при необходимости дать аргумент конструктору базового класса ситуация несколько усложняется. Во-первых, все необходимые аргументы базового и проиизводгого классов перелаются конструктору производно класса, затем, используя расширенную форму обьяиления конструктора производного класса, coответствующие аргументы передаются дальше в базовый класс. Синтаксис передачи аргументов из производного в базовый класс показан ниже
коструктор_произв_класса(саисок-арг): базов_класс(список арг) {
// тело конструктора производного класса
}
Для базового и производного классов допустимо использовать одни и те же аргументы.
В этой программе показано, в каком порядке выполняются конструкторы и деструкторы базового и производного классов:
#include <iostream>
#include <windows>
using namespace std;
class base {
public:
base(){cout << "Работа конструктора базового класса\n"; }
~base(){cout << "Работа деструктора базового класса\n"; }
};
class derived: public base {
public:
derived() { cout<<"Работа конструктора производного класса\n ";}
~derived() { cout<<"Работа деструктора производного класса\n ";}
};
int main(){
SetConsoleOutputCP(1251);
derived abc;
return 0;
}
После выполнения программы на экран выводится следующее:
В следующей программе показана передача аргументов конструктору производного класса:
#include <iostream>
#include <windows>
using namespace std;
class base {
public:
base(){cout<<"Работа конструктора базового класса\n";}
~base(){cout<<"Работа деструктора базового кдаоса\n";}
};
//================================
class derived: public base {
int j;
public:
derived(int n){
cout<<"Работа конструктора производного класса\n";
j=n;
}
~derived(){cout<<"Работа деструктора производного класса\n";}
void showj(){cout<<j<<'\n'; }
};
//==================================
int main() {
SetConsoleOutputCP(1251);
derived abc(10);
abc.showj();
return 0;
}
Обратите внимание, что аргумент передается конструктору производного класса обычным образом.
В следующем примере у конструкторов производного и базового классов имеют аргументы. В этом особом случае оба конструктора исполняют один и тот же аргумент, и производный класс просто передает этот аргумент в базовый класс.
#include <iostream>
#include <windows>
using namespace std;
class base {
int i;
public:
base(int n){cout<<"Работа конструктора базового класса\n";
i=n;
}
~ base(){cout<<"Работа деструктора базового класса\n";}
void showi(){cout<<i<<’\n’;}
};
//======================================
class derived:public base{
int j;
public:
derived(int n):base(n){ // передача аргумента
// в базовый класс
cout<<"Работа конструктора производного класса\n";
j=n;
}
~derived(){cout<<"Работа деструктора производного класса\n";
}
void showj() { cout<<j<<'\n';}
};
//==========================================
int main(){
SetConsoleOutputCP(1251);
derived abc(10);
abc.showi();
abc.showj();
return 0;
}
Обратите внимание на объявление конструктора производного класса. Отметте как параметр n (который получает аргумент при инициализации) используется в конструкторе derived() и передается конструктору base().
Обычно конструкторы базового и производного классов не используют один и тот же аргумент. В этом случае, при необходимости передать каждому конструктору класса один или несколько аргументов, вы должны передать конструктору производного класса все аргументы, необходимые конструкторам обоих классов. Затем конструктор производного класса просто передает конструктору базового класса те аргументы, которые ему требуются. Например,
#include <iostream>
#include <windows>
using namespace std;
class base {
int i;
public:
base(int n){cout<<"Работа конструктора базового класса\n";
i=n;
}
~ base(){cout<<"Работа деструктора базового класса\n";}
void showi(){cout<<i<<’\n’;}
};
class derived:public base{
int j;
public:
derived(int n,int m):base(m){ // передача аргумента
// в базовый класс
cout<<"Работа конструктора производного класса\n";
j=n;
}
~derived(){cout<<"Работа деструктора производного класса\n";
}
void showj() { cout<<j<<'\n';}
};
int main(){
SetConsoleOutputCP(1251);
derived abc(10,20);
abc.showi();
abc.showj();
return 0;
}
Конструктору производного класса совершенно нет необходимости обрабатывать аргумент, предназначенный для передачи в базовый класс, если производному классу этот аргумент не нужен, он его просто игнориру передает в базовый класс. Например, в этом фрагменте параметр n конструктором derived() не используется. Вместо этого он просто передается кон руктору base().
#include <iostream>
#include <windows>
using namespace std;
class base {
int i;
public:
base(int n){cout<<"Работа конструктора базового класса\n";
i=n;
}
~ base(){cout<<"Работа деструктора базового класса\n";}
void showi(){cout<<i<<’\n’;}
};
class derived:public base{
int j;
public:
derived(int n):base(m){ // передача аргумента
// в базовый класс
cout<<"Работа конструктора производного класса\n";
j=0;//аргумент здесь не используется
}
~derived(){cout<<"Работа деструктора производного класса\n";
}
void showj() { cout<<j<<'\n';}
};
int main(){
SetConsoleOutputCP(1251);
derived abc(10,20);
abc.showi();
abc.showj();
return 0;
}