Понятие статического и динамического связывания

Связывание – подстановка в коды программы вызовов конкретных функций – методов класса. Имеет смысл только для производных классов.

Обычно компилятор имеет необходимую информацию для того, чтобы определить, какая функция имеется в виду. Например, если в программе встречается вызов obj.f(), компилятор однозначно выбирает функцию f() в зависимости от типа адресата obj. Если в программе используются указатели на экземпляры класса: ptr->f(), выбор функции - метода класса определяется типом указателя.

Если выбор функции выполняется на этапе компиляции, мы имеем дело со статическим связыванием.

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

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

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

Виртуальные функции

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

Виртуальные функции:

- имеют в прототипе в базовом классе ключевое слово virtual;

- обязательно функции-члены класса:

- Во всех производных классах должны иметь такой же прототип (указание слова virtual в производных классах не обязательно).

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

Пример: классы Точка и Окружность.

class Point{

protected:

int x, y;

public:

. . .

virtual void print(); };

class Circle: public Point{

private:

int rad;

public:

. . .

void print(); // можно virtual void print(); };

void Point::print()

{ cout << "Point (" << x << ", " << y << ")"; }

void Circle::print()

{ cout << "Circle with center in "; Point::print();

cout << "and radius " << rad;

}

Использование:

Point p1(3,5), p2(1,1), *pPtr;

Cicle c1(1), c2(p2, 1);

pPtr = &p1; pPtr->print(); // получим: Point (3, 5)

pPtr = &c2; pPtr->print(); // получим:

Circle with center in Point (1, 1) and radius 1

Пример использования динамического связывания: список

Наиболее часто динамическое связывание используется с контейнерными классами, содержащими указатель на базовый класс; в такие контейнерные классы можно включать информацию, относящуюся и к базовому, и к любым производным классам.

Рассмотрим пример – список, содержащий и точки, и окружности.

struct Item{

Point *info;

Item *next;

// конструктор

Item():info(NULL), next(NULL){}

Item(Point *p):info(p), next(NULL){} };

class List{

private:

Item *head;

public:

List():head(NULL){}

void insert(Point *p){p->next = head; head = p;}

void print(); };

void List::print()

{ for(Item *cur = head; cur; cur = cur->next){

cur->info->print();

cout << endl; } }

Использование класса:

List mylist;

Point *p = new Point(1,2);

mylist.insert(p);

p = new Cicle(1,2,1);

mylist.insert(p);

mylist.print();

получим:

Circle with center in Point (1, 2) and radius 1

Point (1, 2)

1. Понятие и назначение итераторов. Проектирование, реализация и использование итератора.

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

Получить итератор можно различными методами классов контейнеров, например итераторы, указывающие на первый элемент контейнера можно получить, вызвав функцию .begin() в классе контейнера, а вызвав в том же классе контейнера функцию .end(), можно получить указатель на место, находящееся за позицией последнего элемента контейнера.

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

Одним из главных преимуществ итераторов является то, что он не позволяет так легко, как с помощью обычного индексирования выйти за пределы конейнера: если при их использовании происходит выход за пределы контейнера, происходит исключение, которое можно отловить, используя средства языка C++. При использовании же индексирования, если произошел выход за пределы контейнера, можно получить, порой, очень трудно обнаружаемые ошибки. Однако, если алгоритм не подразумевает последовательного обхода контейнера (например, обход списка), лучше использовать индексирование — с ним код выглядит более понятным и наглядным.

list<int> l;

list<int>::iterator i = l.begin();

while ( i != l.end() )

{

//do something

++i;

}

пример использования для обхода списка

vector<int> v;

for ( vector<int>::iterator i = v.begin(); i < v.end(); ++i )

{

//do something

}

пример использования для обхода вектора

1. Множественное наследование: определение, реализация, использование экземпляров производного и базовых классов. Возможные неоднозначности, их устранение. Виртуальные классы, их назначение. Определение и реализация производных классов, использующих виртуальные базовые классы. Вызов конструкторов виртуального класса.

Стр 164

1. Файловый потоковый ввод-вывод: иерархия и назначение классов. Основные методы для организации потокового ввода-вывода. Определение состояния потока. Организация работы с файлами: классы, основные методы. Реализация произвольного доступа к файлам.

Поток — это общее название потока данных. В C++ поток представляет собой объект некоторого класса. Именно поэтому вы могли встретить в листингах потоковые объекты cin и cout. Разные потоки предназначены для представления разных видов данных.

Одним из аргументов в пользу потоков является простота использования. Каждый объект сам знает, как он должен выглядеть на экране. Это избавляет программиста от одного из основных источников ошибок. Другой причиной является то, что можно перегружать стандартные операторы и функции вставки (<<) и извлечения (>>) для работы с создаваемыми классами. Это позволяет работать с собственными классами как со стандартными типами, что, опять же, делает программирование проще и избавляет от множества ошибок. Оказывается, потоковый ввод/вывод, нужен. Потому что это лучший способ записывать данные в файл, лучший способ организации данных в памяти для последующего использования при вводе/выводе текста в окошках и других элементах графического интерфейса пользователя (GUI).

ИЕРАРХИЯ.

Потоковые классы имеют довольно сложную иерархическую структу-ру. Операция извлечения >> является методом класса istream, опера-ция вставки << — методом класса ostream. Оба этих класса являются наследниками ios. Некоторые манипуляторы описаны в IOMANIP, а некоторые классы для работы с объектами «в памяти» определены в STRSTREAM. Класс ios является базовым для всей иерархии. Он со-держит множество констант и методов, общих для операций ввода/ вывода любых видов. Класс istream содержит функции: get(), getline(), read() и перегружаемую операцию извлечения (>>). Класс ostream содержит функции: put(), write() и перегружаемую операцию вставки (<<). Класс iostream — наследник одновременно классов istream и ostream (пример множественного наследования). Его производные классы могут использоваться при работе с объектами – дисковые файлы, которые могут быть открыты одновременно для записи и чте-ния. Классы: istream_withassign, ostream_withassign,iostream_withas-sign — являются наследниками istream, ostream и iostream соответ-ственно. Они добавляют к этим классам операторы присваивания.

Для поддержки ввода и вывода на основе потоков используются билиотеки fstream:

· Ifstream – класс, с помощью которого осуществляется чтение из файла

· Ofstream- класс, с помощью которого осуществляется запись в файл

· Fstream – класс дя чтения и записи в файл.

Необходимая директива: #include <fstream>.

Работа с файлами предполагает след операции:

1. Создание потокового объекта

2. Открытие потока и связывание его с файлом

3. Осуществление чтения и записи

4. Закрытие файла.

Запись данных в текст файл:

1. Шаблоны: назначение и типы шаблонов. Шаблоны функций: определение, реализация. Использование функций шаблона. Параметризованные классы: определение и реализация. Использование экземпляров класса шаблона. Использование механизма наследования в шаблонах классов.

Шаблон типа для класса задает способ построения отдельных классов, подобно тому, как описание класса задает способ построения его отдельных объектов. Можно определить стек, содержащий элементы произвольного типа:template<class T>class stack {T* v;T* p;int sz;public: stack( int s ) {v = p = new T[sz=s]; } ~stack() { delete [] v; } void push(T a) { *p++ = a; } T pop() const { return * --p; } int size() const { return p-v; } };Для простоты не учитывался контроль динамических ошибок. Не считая этого, пример полный и вполне правдоподобный. Префикс template <class T> указывает, что описывается шаблон типа с параметром T, обозначающим тип, и что это обозначение будет использоваться в последующем описании. После того, как идентификатор T указан в префиксе, его можно использовать как любое другое имя типа. Область видимости T продолжается до конца описания, начавшегося префиксом template <class T>. Отметим, что в префиксе T объявляется типом, и оно не обязано быть именем класса. Так, ниже в описании объекта sc тип T оказывается просто char.Имя шаблонного класса, за которым следует тип, заключенный в угловые скобки <>, является именем класса (определяемым шаблоном типа), и его можно использовать как все имена класса. Например, ниже определяется объект sc класса stack<char>: stack<char> sc(100); // стек символовМожно сказать, что шаблон типа - это макроопределение, подчиняющееся правилам именования, типов и областей видимости, принятым в Си++. Это, конечно, упрощение, но это такое упрощение, которое помогает избежать больших недоразумений. В частности, применение шаблона типа не предполагает каких-либо средств динамической поддержки помимо тех, которые используются для обычных "ручных" классов. Не следует так же думать, что оно приводит к сокращению программы.Обычно имеет смысл вначале отладить конкретный класс, такой, например, как stack_char, прежде чем строить на его основе шаблон типа stack <T>. С другой стороны, для понимания шаблона типа полезно представить себе его действие на конкретном типе, например int или char*, прежде, чем пытаться представить его во всей общности.Имея определение шаблонного класса stack, можно следующим образом определять и использовать различные стеки: stack<shape*> ssp(200); // стек указателей на фигуры stack<Point> sp(400); // стек структур Point void f(stack<complex>& sc) // параметр типа `ссылка на // complex' { sc.push(complex(1,2)); complex z = 2.5*sc.pop(); stack<int>*p = 0; // указатель на стек целых p = new stack<int>(800); // стек целых размещается // в свободной памяти for ( int i = 0; i<400; i++) { p->push(i); sp.push(Point(i,i+400)); } // ... }Поскольку все функции-члены класса stack являются подстановками, и в этом примере транслятор создает вызовы функций только для размещения в свободной памяти и освобождения.Функции в шаблоне типа могут и не быть подстановками, шаблонный класс stack с полным правом можно определить и так: template<class T> class stack { T* v; T* p; int sz; public: stack(int); ~stack(); void push(T); T pop(); int size() const; };В этом случае определение функции-члена stack должно быть дано где-то в другом месте, как это и было для функций-членов обычных, нешаблонных классов. Подобные функции так же параметризируются типом, служащим параметром для их шаблонного класса, поэтому определяются они с помощью шаблона типа для функции. Если это происходит вне шаблонного класса, это надо делать явно: template<class T> void stack<T>::push(T a) { *p++ = a; } template<class T> stack<T>::stack(int s) { v = p = new T[sz=s]; }Отметим, что в пределах области видимости имени stack <T> уточнение <T> является избыточным, и stack<T>::stack - имя конструктора.Задача системы программирования, а вовсе не программиста, предоставлять версии шаблонных функций для каждого фактического параметра шаблона типа. Поэтому, для приведенного выше примера, система программирования должна создать определения конструкторов для классов stack<shape*>, stack<Point> и stack<int>, деструкторов для stack<shape*> и stack<Point>, версии функций push() для stack<complex>, stack<int> и stack<Point> и версию функции pop() для stack<complex>. Такие создаваемые функции будут совершенно обычными функциями-членами, например: void stack<complex>::push(complex a) { *top++ = a; }Здесь отличие от обычной функции-члена только в форме имени класса. Точно так же, как в программе может быть только одно определение функции-члена класса, возможно только одно определение шаблона типа для функции-члена шаблонного класса. Если требуется определение функции-члена шаблонного класса для конкретного типа, то задача системы программирования найти шаблон типа для этой функции-члена и создать нужную версию функции. В общем случае система программирования может рассчитывать на указания от программиста, которые помогут найти нужный шаблон типа.Важно составлять определение шаблона типа таким образом, чтобы его зависимость от глобальных данных была минимальной. Дело в том, шаблон типа будет использоваться для порождения функций и классов на основе заранее неизвестного типа и в неизвестных контекстах. Практически любая, даже слабая зависимость от контекста может проявиться как проблема при отладке программы пользователем, который, вероятнее всего, не был создателем шаблона типа. К совету избегать, насколько это возможно, использований глобальных имен, следует относиться особенно серьезно при разработке шаблона типа.

Шаблоны типа для функций

Стр 215