Class derived : public base

{ int j;

public:

derived(int n, int m): base(m)

{cout<<”Derived constructor”; j=n;}

~derived( ) {cout<<”Derived destructor”;}

void show_j( ) {cout<<j<<’\n’;}

};

void main( )

{

derived obj(10,20);

obj.show_i( );

obj.show_j( );

}

Оба класса в примере имеют конструкторы и деструкторы. Вначале на экран выведется: Base constructor, затем - Derived constructor. Конструктор производного класса объявлен так, что требует два аргумента; один он использует сам, другой передает в базовый класс. В результате инициализируются переменные i и j. Затем на экран будет выведено: 20 10.

После этого выводится сообщение: Derived destructor, а потом

Base destructor.

13. Понятие полиморфизма в С++.

Полиморфизм - это придание одного и того же имени действию, которое выполняется над различными объектами классов, находящихся в иерархическом подчинении. Для каждого из объектов это действие может выполняться по своему.

Для совместимости объектов существует три правила:

1. Объекту родительского класса можно присвоить любой объект порожденного класса (обратное - недопустимо).
2. Указатели на родительский объект можно присвоить на любой порожденный объект.
3. Если фактический параметр является некоторым объектом или указателем на объект, то формальный параметр может быть либо родительским объектом либо указателем на родительский объект.

14. Технология перегрузки функций.

Цель перегрузки функций состоит в том, чтобы функция с одним именем по-разному выполнялась и возвращала разные значения при обращении к ней с разными по типам и количеству фактическими параметрами.

Для обеспечения перегрузки функций необходимо для каждого имени определить, сколько разных функций связано с ним, т.е. сколько вариантов сигнатур допустимы при обращении к ним. Предположим, что функция выбора максимального значения элемента из массива должна работать для массивов типа int, long, float, double. В этом случае придется написать четыре разных варианта функции с одним и тем же именем.
Распознавание перегруженных функций при вызове выполняется по их сигнатурам. Перегруженные функции поэтому должны иметь одинаковые имена, но спецификации их параметров должны различаться по количеству и (или) по типам, и (или) по расположению.
При использовании перегруженных функций нужно с осторожностью задавать начальные значения их параметров.
Перегрузка операций производится с помощью специальной функции operator согласно следующей форме:
тип operator знак_операции (типы аргументов) {...}. Перегруженная операция может быть определена как компонент класса; в этом случае она имеет один параметр или вообще не имеет параметров. У дружественной перегруженной операции может быть один или два параметра. Поэтому бинарные операции следует перегружать как дружественные.

Перегружаться могут практически все операции (исключение - оператор принадлежности ::, операторы ..* ?: sizeofn символ #).

15. Перегрузка операторов.

Перегрузка оператора состоит в изменении смысла оператора (например, оператора плюс (+), который обычно в C++ используется для сложения) при использовании его с определенным классом. В данном уроке вы определите класс string и перегрузите операторы плюс и минус. Для объектов типа string оператор плюс будет добавлять указанные символы к текущему содержимому строки. Подобным образом оператор минус будет удалять каждое вхождение указанного символа из строки. К концу данного урока вы изучите следующие основные концепции:

Вы перегружаете операторы для улучшения удобочитаемости ваших программ, но перегружать операторы следует только в том случае, если это упрощает понимание вашей программы.

Для перегрузки операторов программы используют ключевое слово C++ operator.

Переопределяя оператор, вы указываете функцию, которую C++ вызывает каждый раз, когда класс использует перегруженный оператор. Эта функция, в свою очередь, выполняет соответствующую операцию.

Если ваша программа перегружает оператор для определенного класса, то смысл этого оператора изменяется только для указанного класса, оставшаяся часть программы будет продолжать использовать этот оператор для выполнения его стандартных операций.

C++ позволяет перегружать большинство операторов, за исключением четырех, перечисленных в таблице 24, которые программы не могут перегружать.

Перегрузка операторов может упростить наиболее общие операции класса и улучшить читаемость программы.

16. Указатели. Операции с указателями.

Для доступа к членам объекта через сам объект используется оператор «точка» (.). Если же используется указатель на объект, тогда необходимо использовать оператор «стрелка» (—>). Ис­пользование операторов «точка» и «стрелка» аналогично их использованию для структур и объе­динений.

Указатель на объект объявляется с использованием того же синтаксиса, что и указатели на данные других типов. В следующей программе создается простой класс с именем P_example и определяется объект этого класса ob, а также указатель р на объект P_example. Ниже проиллюс­трировано, как получить доступ к объекту ob непосредственно и опосредованно с использовани­ем указателя:

// простой пример использования указателя на объект
#include <iostream.h>
class P_example {
int num;
public:
void set_num(int val) {num = val; }
void show_num();
};
void P_example::show_num()
{
cout << num << " \n";
}
int main()
{
P_example ob, *p; // объявление объекта и указателя на него
ob.set_num(1); // прямой доступ к ob
ob.show_num();
р = &ob; // присвоение р адреса ob
p->show_num(); // доступ к ob с помощью указателя
return 0;
}

Инкремент или декремент указателя изменяет его таким образом, что он всегда указывает на следующий элемент базового типа. То же самое справедливо и для объектов. Следующий пример модифицирует предыдущую программу, в результате чего ob становится массивом из двух эле­ментов типа P_example. Обратим внимание на инкремент и декремент указателя р, с помощью которого осуществляется доступ к элементам массива:

// увеличение указателя на объект
#include <iostream.h>
class P_example {
int num;
public:
void set_num(int val) {num = val;}
void show_num();
};
void P_example::show_num()
{
cout << num << "\n";
}
int main()
{
P_example ob[2], *p;
ob[0].set_num(10); // прямой доступ к объекту
ob[1].set_num(20);
p = &ob[0]; // получение указателя на первый элемент
p->show_num(); // вывод значения ob[0] с помощью указателя
р++; // переход к следующему объекту
p->show_num(); // вывод значения ob[1] с помощью указателя
р--; // переход к предыдущему объекту
p->show_num(); // вывод значения оb [0]
return 0;
}

Программа выводит на экран числа 10, 20, 10.

17. Указатели на производные классы.

Указатели на базовый тип и на производный тип зависимы. Пусть имеем базовый тип B_class и производный от B_class тип D_class. В языке С++ всякий указатель, объявленный как указатель на B_class, может быть также указателем на D_class:

B_class *р; // указатель на объект типа B_class

B_class B_ob; // объект типа B_class

D_class D_ob; // объект типа D_class

После этого можно использовать следующие операции:

p=&B_ob; // Указатель на объект типа B_class

p=&D_ob; // Указатель на объект типа D_class

Все элементы классаD_class, наследуемые от классаB_class, могут быть доступны через использование указателя р. Однако на элементы, объявленные вD_class, нельзя ссылаться, используя р. Если требуется иметь доступ к элементам, объявленным в производном классе, используя указатель на базовый класс, надо привести его к указателю на производный тип.

Например, можно сделать так:

((D_class *)p) -> f();

Здесь функция f() – член класса D_class. Внешние круглые скобки необходимы. Хотя указатель на базовый класс может быть использован как указатель на производный класс, обратное неверно: нельзя использовать указатель на производный класс для присваивания ему адреса объекта базового класса. И наконец, указатель увеличивается и уменьшается при операциях ++ и — относительно его базового типа. Когда указатель на базовый класс указывает на производный класс, увеличение указателя не делает его указывающим на следующий элемент производного класса.

18. Технология использования виртуальных функций.

19. Ссылки. Отличие ссылок от указателей.

ссылка — это простой ссылочный тип, менее мощный, но более безопасный, чем указатель, унаследованый от языка Си.

C++ ссылки отличаются от указателей несколькими особенностями:

• Невозможно ссылаться напрямую на объект ссылочного типа после его определения; каждое упоминание его имени напрямую представляет объект, на который он ссылается.
• В качестве результата первого указания не могут быть выполнены никакие арифметические вычисления, приведения типов, взятия адреса и т.п.
• После создания ссылки ее нельзя перевести на другой объект; в таких случаях говорят, не может быть переопределена. Это часто делают с указателями.
• Ссылки не могут быть null (т.е.указывать в никуда), тогда как указатели - могут; каждая ссылка ссылается на некий объект, вне зависимости от его корректности.
• Ссылки не могут быть неинициализированными. Так как невозможно переинициализировать ссылку, она должна быть инициализирована сразу после создания. В частности, локальные и глобальные переменные должны быть проинициализированы там же, где они определены, а ссылки, которые являются данными-членами сущностей класса, должны быть инициализированы в списке инициализатора конструктора класса.

Указатели предназначены для хранения адресов областей памяти, а cсылка представляет собой синоним имени, указанного при инициализации ссылки. Далее подробно рассматриваются эти важные темы.

20. Технология передачи ссылок на объекты.

21. Технология использования ссылок в качестве возвращаемого значения функции.

22. Понятие массива. Технология работы с массивами.

Массив(array)-это множество однотипных данных (переменных), объединенных под одним именем. В С++ массивы бывают как одномерные, так и многомерные.

<Тип данных в массиве><имя массива>[количество элементов массива];

Элементы массива располагаются в памяти последовательно, друг за другом.

Пример:

Int mzcoding[5];

Выше мы объявили массив с целочисленным типом данных и размером в пять элементов.

Чтобы нам выбрать массив и вывести его значения, нам нужно обратиться к нему по его индексу. Все элементы массива начинаются с нуля, то есть первый элемент имеет нулевой индекс.

#include <iostream>

02.#include <conio.h>

03.#include <clocale>

04.using namespace std;

05.int main()

06.{

07.setlocale(LC_CTYPE,"Russian");

08.int mzcoding [5];

09.int res;

10.mzcoding[0]=20;

11.mzcoding[1]=30;

12.mzcoding[2]=40;

13.mzcoding[3]=50;

14.mzcoding[4]=60;

15.for(res=0; res<=5; res++){

16.cout << mzcoding[res] << "\n";

17.}

18.

19._getch();

20.}

В С++ предусмотрена инициализация массивов! Формат инициализации массивов похож на формат переменных с незначительными отличиями:

тип имя_массива[размер] {значения}

1. Многомерные массивы.

Простейшим многомерным массивом является двумерный.

int twoArr [5] [15];

Заметьте в отличие от большинства других языков программирования где значения разделяются запятой, в С++ все они хранятся в отдельных квадратных скобках. Допустим для получения доступа к элементу массива с координатами 5.5, то следует использовать

int line [5][5];

Если у массива три значения, то его называют трехмерным, четыре значения четырех мерным и т.д. Но чтобы было проще стали называть такие массивы многомерными. Рассмотрим пример многомерного массива:

int six_numbers [1][2][3][4][5][6];

24. Символьные строки.

Символьные строки хранят такую информацию, как имена файлов, названия книг, имена служащих и другие символьные сочетания. Большинство программ на C++ широко используют символьные строки. Далее вы узнаете, что в C++ символьные строки хранятся в массиве типа char, который заканчивается символом NULL (или ASCII 0). В данном уроке символьные строки рассматриваются более подробно. Вы узнаете, как хранить и обрабатывать символьные строки, а также как использовать функции библиотеки этапа выполнения, которые манипулируют символьными строками. К концу этого урока вы освоите следующие основные концепции:

Чтобы объявить символьную строку, вы должны объявить массив типа char,

Чтобы присвоить символы символьной строке, ваши программы просто присваивают символы элементам массива символьных строк.

Программы C++ используют символ NULL (ASCII 0), чтобы отметить последний символ строки.

C++ позволяет вашим программам инициализировать символьные строки при их объявлении.

Программы могут передавать символьные строки в функцию, как и любой массив.

Большинство библиотек этапа выполнения C++ обеспечивают набор функций, которые управляют символьными строками.

Программы на C++ хранят символьные строки как массив типа char. Большинство программ широко используют символьные строки.

25. Определение символьных строк в программах.

Программисты на C++ широко используют символьные строки для хранения имен пользователей, имен файлов и другой символьной информации.

Для объявления символьной строки внутри программы просто объявите массив типа char с количеством элементов, достаточным для хранения требуемых символов. Например, следующее объявление создает переменную символьной строки с именем filename, способную хранить 64 символа (не забывайте, что символ NULL является одним из этих 64 символов):

char filename[64];

Как видно из рис. 17.1, это объявление создает массив с элементами, индексируемыми от filename[0] до filename[63].

Рис. 17.1.C++ трактует символьную строку как массив типа char.

Главное различие между символьными строками и другими типами массивов заключается в том, как C++ указывает последний элемент массива, Как вы уже знаете, программы на C++ представляют конец символьной строки с помощью символа NULL, который в C++ изображается как специальный символ '\0'. Когда вы присваиваете символы символьной строке, вы должны поместить символ NULL ('\0') после последнего символа в строке. Например, следующая программа ALPHABET. CPP присваивает буквы от А до Я переменной alphabet,используя цикл for. Затем программа добавляет символ NULL в эту переменную и выводит ее с помощью cout.

#include <iostream.h>

void main(void)

{
char alphabet [34]; // 33 буквы плюс NULL char letter;
int index;
for (letter = 'A', index = 0; letter <= 'Я';
letter++, index++) alphabet[index] = letter;
alphabet[index] = NULL;
cout << "Буквы " << alphabet;
}

Как видите, программа присваивает строке символ NULL, чтобы указать последний символ строки:

alphabet[index] = NULL;

Когда выходной поток cout выводит символьную строку, он по одному выводит символы строки, пока не встретит символ NULL. Короче говоря, cимвол NULL указывает программе последний символ в строке.

Обратите внимание на цикл for, который появляется в предыдущей программе. Как видите, цикл инициализирует и увеличивает две переменные (letter и index). Когда цикл for инициализирует или увеличивает несколько переменных, разделяйте операции запятой (запятая тоже является оператором C++):

for (letter = 'A', index = 0; letter <= 'Я'; letter++, index++)

C++ автоматически добавляет NULL к строковым константам

Все созданные вами программы использовали символьные строковые константы, заключенные внутри двойных кавычек, как показано ниже:

"Это строковая константа"

При создании символьной строковой константы компилятор C++ автоматически добавляет символ NULL, как показано на рис. 17.2.

Рис.17.2. Компилятор C++ автоматически добавляет символ NULL к строковым константам.

Когда ваши программы выводят символьные строковые константы с помощью выходного потока cout, cout использует символ NULL (который компилятор добавляет к строке) для определения последнего символа вывода.