WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 || 3 |

«Министерство образования Республики Беларусь Учреждение образования «Белорусский государственный университет информатики и радиоэлектроники» Кафедра электронных вычислительных машин Ю.А. Луцик, А.М. ...»

-- [ Страница 2 ] --

// идентификация состояний virtual living *next(world w)=0;

// расчет next virtual void print()=0;

// вывод содержимого поля модели };

void living::sums(world w,int sm[]) { int i,j;

sm[EMPTY]=sm[GRASS]=sm[RABBIT]=sm[FOX]=0;

int i1=-1,i2=1,j1=-1,j2=1;

if(row==0) i1=0;

// координаты внешних клеток модели if(row==N) i2=0;

if(col==0) j1=0;

if(col==N) j2=0;

for(i=i1;

i<=i2;

++i) for(j=j1;

j<=j2;

++j) sm[w[row+i][col+j]->who()]++;

} В базовом классе living объявлены две чисто виртуальные функции who() и next() и одна обычная функция sums(). Моделирование имеет правила для решения о том, кто продолжает жить в следующем цикле. Они основаны на со седствующих популяциях в некотором квадрате. Глубина иерархии наследова ния – один уровень.

// текущий класс – только хищники class fox:public living { protected:

int age;

// используется для принятия решения о смерти лиса public:

fox(int r,int c,int a=0):living(r,c),age(a){} state who() {return FOX;

} // отложенный метод для foxes living *next(world w);

// отложенный метод для foxes void print(){cout << " ли ";

} };

// текущий класс – только жертвы class rabbit:public living { protected:

int age;

// используется для принятия решения о смерти кролика public:

rabbit(int r,int c,int a=0):living(r,c),age(a){} state who() {return RABBIT;

} // отложенный метод для rabbit living *next(world w);

// отложенный метод для rabbit void print(){cout << " кр ";

} };

// текущий класс – только растения class grass:public living { public:

grass(int r,int c):living(r,c){} state who() {return GRASS;

} // отложенный метод для grass living *next(world w);

// отложенный метод для grass void print(){cout << " тр ";

} };

// жизнь отсутствует class empty : public living { public:

empty(int r,int c):living(r,c){} state who() {return EMPTY;

} // отложенный метод для empty living *next(world w);

// отложенный метод для empty void print(){cout << " ";

} };

Характеристика поведения каждой формы жизни фиксируется в версии next(). Если в окрестности имеется больше grass, чем rabbit, grass остается, ина че grass будет съедена.

living *grass::next(world w) { int sum[STATES];

sums(w,sum);

if(sum[GRASS]>sum[RABBIT]) // кролик ест траву return (new grass(row,col));

else return(new empty(row,col));

} Если возраст rabbit превышает определенное значение DRAB, он умирает либо, если поблизости много лис, он может быть съеден.

living *rabbit::next(world w) { int sum[STATES];

sums(w,sum);

if(sum[FOX]>=sum[RABBIT]) // лис ест кролика return (new empty(row,col));

else if(age>DRAB) // кролик слишком старый return(new empty(row,col));

else return(new rabbit(row,col,age+1));

// кролик постарел } Fox тоже умирает от старости.

living *fox::next(world w) { int sum[STATES];

sums(w,sum);

if(sum[FOX]>5) // слишком много лис return (new empty(row,col));

else if(age>DFOX) // лис слишком старый return(new empty(row,col));

else return(new fox(row,col,age+1));

// лис постарел } // заполнение пустой площади living *empty::next(world w) { int sum[STATES];

sums(w,sum);

if(sum[FOX]>1) // первыми добавляются лисы return (new fox(row,col));

else if(sum[RABBIT]>1) // вторыми добавляются кролики return (new rabbit(row,col));

else if(sum[GRASS]) // третьими добавляются растения return (new grass(row,col));

else return (new empty(row,col));

// иначе пусто } Массив world представляет собой контейнер для жизненных форм. Он должен иметь в собственности объекты living, чтобы распределять новые и уда лять старые.

// world полностью пуст void init(world w) { int i,j;

for(i=0;

i

++i) for(j=0;

j

++j) w[i][j]=new empty(i,j);

} // генерация исходной модели мира void gener(world w) { int i,j;

for(i=0;

i

++i) for(j=0;

j

++j) { if(i%2==0 && j%3==0) w[i][j]=new fox(i,j);

else if(i%3==0 && j%2==0) w[i][j]=new rabbit(i,j);

else if(i%5==0) w[i][j]=new grass(i,j);

else w[i][j]=new empty(i,j);

} } // вывод содержимого модели мира на экран void pr_state(world w) { int i,j;

for(i=0;

i

++i) { cout<

for(j=0;

j

++j) w[i][j]->print();

} cout << endl;

} // новый world w_new рассчитывается из старого world w_old void update(world w_new, world w_old) { int i,j;

for(i=0;

i

++i) for(j=0;

j

++j) w_new[i][j]=w_old[i][j]->next(w_old);

} // очистка мира void dele(world w) { int i,j;

for(i=1;

i

++i) for(j=1;

j

++j) delete(w[i][j]);

} Модель имеет odd и even мир. Их смена является основой для расчета по следующего цикла.

int main() { world odd,even;

int i;

init(odd);

init(even);

gener(even);

// генерация начального мира pr_state(even);

// выводит типы состояний gener for(i=0;

i

++i) // моделирование { //getch();

if(i%2) { update(even,odd);

pr_state(even);

dele(odd);

} else { update(odd,even);

pr_state(odd);

dele(even);

} } return 1;

} Множественное наследование В языке С++ имеется возможность образовывать производный класс от нескольких базовых классов. Общая форма множественного наследования име ет вид:

class имя_произв_класса : имя_базового_кл 1,…,имя_базового_кл N { содержимое класса } Иерархическая структура, в которой производный класс наследует от не сколько базовых классов, называется множественным наследованием. В этом случае производный класс, имея собственные компоненты, имеет доступ к protected- и public-компонентам базовых классов.

Конструкторы базовых классов при создании объекта производного клас са вызываются в том порядке, в котором они указаны в списке при объявлении производного класса.

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

class A {public: void fun(){} };

class B {public: void fun(){} };

class C : public A, public B { };

main() { C *c=new C;

c->fun();

// error C::f' is ambiguous return 0;

} При таком вызове функции fun() компилятор не может определить, к ка кой из двух функций классов A и B выполняется обращение. Неоднозначность можно устранить, явно указав, какому из базовых классов принадлежит вызы ваемая функция:

c->A:: fun();

или c->B::fun();

Вторая проблема возникает при многократном включении некоторого базового класса:

#include "iostream.h" #include "string.h" class A // БАЗОВЫЙ класс I уровня { char naz[20];

// название фирмы public:

A(char *NAZ) {strcmp(naz,NAZ);

} ~A() {cout << "деструктор класса А" << endl;

} void a_prnt() {cout << naz << endl;

} };

class B1 : public A // ПРОИЗВОДНЫЙ класс (1 Базовый II уровня) { protected:

long tn;

int nom;

public:

B1(char *NAZ,long TN,int NOM): A(NAZ),tn(TN),nom(NOM) {};

~B1() {cout << "деструктор класса В1" << endl;

} void b1_prnt() { A::a_prnt();

cout << " таб. N " << tn <<" подразделение = " << nom <

} };

class B2 : public A // ПРОИЗВОДНЫЙ класс (2 Базовый II уровня) { protected:

double zp;

public:

B2(char *NAZ,double ZP): A(NAZ),zp(ZP) {};

~B2(){cout << "деструктор класса В2" << endl;

} void b2_prnt() { A::a_prnt();

cout << " зар/плата = " << zp << endl;

} };

class C : public B1, public B2 // ПРОИЗВОДНЫЙ класс ( III уровня) { char *fam;

public:

C(char *FAM,char *NAZ,long TN,int NOM,double ZP) :

B1(NAZ,TN,NOM), B2(NAZ,ZP) { fam = new char[strlen(FAM)+1] strcpy(fam,FAM);

};

~C() {cout << "деструктор класса С" << endl;

} void c_prnt() { B1::b1_prnt();

B2::b2_prnt();

cout << " фамилия " << fam<

} };

void main() { C cc("Иванов","мастра",1234,2,555.6),*pt=&cc;

// cc.a_prnt();

ошибка 'C::a_prnt' is ambiguous // pt->a_prnt();

cc.b1_prnt();

pt->b1_prnt();

cc.b2_prnt();

pt->b2_prnt();

cc.c_prnt();

pt->c_prnt();

} В приведенном примере производный класс С имеет по цепочке два оди наковых базовых класса А (A<-B1<-C и A<-B2<-C), для каждого базового клас са А строится свой объект (рис. 2, 3). Таким образом, вызов функции cc.a_prnt();

pt->a_prnt();

некорректен, так как неизвестно, какую из двух функций (какого из двух классов А) требуется вызвать.

A A А A A Объект Объект B C класса D класса D B C В C D Рис. 2. Структура объекта Рис. 3. Иерархия классов Виртуальное наследование Если базовый класс (в приведенном выше примере это класс А) является виртуальным, то будет построен единственный объект этого класса (см. рис. 2).

#include "iostream" using namespace std;

class A // БАЗОВЫЙ виртуальный класс { int aa;

public: A() {} A(int AA) : aa(AA) {} ~A() {} };

class B : virtual public A // ПРОИЗВОДНЫЙ класс (1 Базовый) { char bb;

public: B() {} B(int AA,char BB): A(AA),bb(BB) {} ~B() {} };

class C : virtual public A // ПРОИЗВОДНЫЙ класс (2 Базовый) { float cc;

public: C() {} C(int AA,float CC): A(AA),cc(CC) {} ~C() {} };

class D : public B,public C // ПРОИЗВОДНЫЙ класс (2 Базовый II уровня) { int dd;

public: D() {} D(int AA,char BB,float CC,int DD) :

A(AA),B(AA,BB),C(AA,CC),dd(DD) {} ~D() {} };

void main() { D d(1,'a',2.3,4);

D dd;

} Виртуальный базовый класс всегда инициализируется только один раз. В примере при создании объектов d и dd конструктор класса А вызывается из конструктора класса D первым и только один раз, затем – конструкторы клас сов B и C, в том порядке, в котором они описаны в строке наследования клас сов:

class D : public B, public C.

В одно и то же время класс может иметь виртуальный и невиртуальный базовые классы, например:

class A{ … };

class B1: virtual public A{ … };

class B2: virtual public A{ … };

class B3: public A{ … };

class C: public B1, public B2, public B3 { … };

В этом случае класс С имеет два подобъекта класса А, один наследуемый через классы В1 и В2 (общий для этих классов) и второй через класс В (рис. 4, 5).

A A A A Объект B B1 B класса С В B1 В C Рис. 4. Структура объекта Рис. 5. Иерархия классов при виртуальном наследовании при виртуальном наследовании #include "iostream.h" #include "string.h" class A // БАЗОВЫЙ класс I уровня { char *naz;

// название фирмы public:

A(char *NAZ) { naz=new char[strlen(NAZ)+1];

strcpy(naz,NAZ);

} ~A() { delete naz;

cout << "деструктор класса А" << endl;

} void a_prnt(){cout <<"марка а/м "<< naz << endl;

} };

class B1 : virtual public A // ПРОИЗВОДНЫЙ класс (1 Базовый II уровня) { protected:

char *cv;

// цвет а/м int kol;

// количество дверей public:

B1(char *NAZ,char *CV,int KOL): A(NAZ),kol(KOL) { cv=new char[strlen(CV)+1];

strcpy(cv,CV);

} ~B1() { delete cv;

;

cout << "деструктор класса В1" << endl;

} void b1_prnt() { A::a_prnt();

cout << "цвет а/м" << cv <<" кол-во дверей " << kol <

} };

class B2 : virtual public A // ПРОИЗВОДНЫЙ класс (2 Базовый II уровня) { protected:

int pow;

// мощность а/м double rs;

// расход топлива public:

B2(char *NAZ,int POW,double RS): A(NAZ),pow(POW),rs(RS) {};

~B2(){cout << "деструктор класса В2" << endl;

} void b2_prnt() { A::a_prnt();

cout <<"мощность двигателя "<

cout<

} };

class C : public B1,public B2//ПРОИЗВОДНЫЙ класс (2 Базовый II уровня) { char *mag;

// название магазина public: C(char *NAZ,char *CV,int KOL,int POW,double RS,char *MAG):

B1(NAZ,CV,KOL),B2(NAZ,POW,RS),A(NAZ) { mag =new char[strlen(MAG)];

strcpy(mag,MAG);

} ~C() { delete mag;

cout << "деструктор класса С" << endl;

} void c_prnt() { A::a_prnt();

B1::b1_prnt();

B2::b2_prnt();

cout << " название магазина" << mag <

} };

void main() { C cc("BMW","красный",100,4,8.5,"магазин 1"),*pt=&cc;

cc.a_prnt();

pt->a_prnt();

cc.b1_prnt();

pt->b1_prnt();

cc.b2_prnt();

pt->b2_prnt();

cc.c_prnt();

pt->c_prnt();

} Перегрузка функций Одним из подходов реализации принципа полиморфизма в языке С++ яв ляется использование перегрузки функций. В С++ две и более функций могут иметь одно и то же имя. Компилятор С++ оперирует не исходными именами функций, а их внутренним представлением, которое учитывает количество и тип принимаемых аргументов. В то же время тип возвращаемого функцией зна чения не учитывается. Поэтому для компилятора функции с различным спи ском аргументов – это разные функции, а с одинаковым списком аргументов, но с разными типами возвращаемого значения – одинаковые. Для корректной работы программ последнего следует избегать. Функции, имеющие одинаковые имена, но разные списки аргументов, называются перегруженными. Рассмот рим простой пример перегрузки функции sum, выполняющей сложение не скольких чисел различного типа.

#include "iostream.h" class cls { int n;

double f;

public:

cls(int N,float F) : n(N),f(F) {} int sum(int k) // функция sum с целочисленнным аргументом { n+=k;

return n;

} double sum(double k) // функция sum с дробным аргументом { f+=k;

return f;

} void see() {cout <

} };

void main() { cls obj(1,2.3);

obj.see();

// вывод содержимого объекта cout <

// вызов функции sum с целочисл. аргументом cout <

// вызов функции sum с дробным аргументом } Результат работы программы:

1 2. 3. Перегрузка операторов Имеется ограничение в языках С и С++, накладываемое на операции над известными типами данных (классами) char, int, float и т.д.:

char c, int i,j;

double d,k;

В С и С++ определены множества операций над объектами c,i,j,d,k этих классов, выражаемых через операторы: i+j, j/k, d*(i+j). Большинство операторов (операций) в С++ может быть перегружено (переопределено), в результате чего расширяется диапазон применения этих операций. Когда оператор перегружен, ни одно из его начальных значений не теряет смысла. Просто для некоторого класса объектов определен новый оператор (операция). Для перегрузки (дооп ределения) оператора разрабатываются функции, являющиеся либо компонен тами, либо friend-функциями того класса, для которого они используются. Ос тановимся на перегрузке пока только с использованием компонент- функций класса.

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

Возвращ_тип имя_класса :: operator #(список аргументов) { действия, выполняемые применительно к классу } Вместо символа # ставится значок перегружаемого оператора.

Следует отметить, что нельзя перегрузить триадный оператор ”?:.”, опе ратор ”sizeof” и оператор разрешения контекста ”::”.

Функция operator должна быть либо компонентой класса, либо иметь хотя бы один аргумент типа ”объект класса” (за исключением при перегрузке опера торов new и delete).Это позволит доопределить свойства операции, а не изме нить их. При этом новое значение оператора будет иметь силу только для типов данных, определенных пользователем;

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

Выражение a#b, имеющее первый операнд а стандартного типа данных, не может быть переопределено функцией operator, являющейся компонентом класса. Например, выражение a-4 может быть представлено как a.operator-(4), где а – объект некоторого типа. Выражение вида 4-a нельзя представить в виде 4.operator(a). Это может быть реализовано с использованием глобальных функ ций operator.

Функция operator может быть вызвана так же, как и любая другая функ ция. Использование операции – лишь сокращенная форма вызова функции. На пример, запись вида a=в-с;

эквивалентна a=operator-(b,с).

Перегрузка бинарного оператора Функция operator для перегрузки (доопределения) бинарных операторов может быть описана двумя способами:

как компонента-функция класса с одним аргументом;

как глобальная функция (функция, описанная вне класса) с двумя аргу ментами.

При перегрузке бинарного оператора # выражение a#b может быть пред ставлено при первом способе как a.operator#(b) или как operator #(a,b) при втором способе перегрузки.

Рассмотрим простой пример переопределения операторов *, =, > и == по отношению к объекту, содержащему декартовы координаты точки на плос кости. В примере использован первый способ перегрузки.

#include "iostream.h" class dek_koord { int x,y;

// декартовы координаты точки public:

dek_koord(){};

dek_koord(int X,int Y): x(X),y(Y) {} dek_koord operator*(const dek_koord );

dek_koord operator=(const dek_koord);

dek_koord operator>(const dek_koord);

void see();

};

dek_koord dek_koord::operator*(const dek_koord a) { dek_koord tmp;

// перегрузка операции * tmp.x=x*a.x;

tmp.y=y*a.y;

return tmp;

} dek_koord dek_koord::operator =(const dek_koord a) { x=a.x;

// перегрузка операции = y=a.y;

return *this;

} dek_koord dek_koord::operator >(const dek_koord a) { if (x

// перегрузка операции > if (y

return *this;

} int dek_koord::operator ==(const dek_koord a) { if (x-a.x==0 && y-a.y==0) return 0;

// перегрузка операции == if (x-a.x>0 && y-a.y>0) return 1;

if (x-a.x<0 && y-a.y<0) return -1;

else return 2;

// неопределенность } void dek_koord::see() { cout << "координата х = " << x << endl;

cout << "координата y = " << y << endl;

} void main() { dek_koord A(1,2), B(3,4), C;

int i;

A.see();

B.see();

C=A*B;

C.see();

C=A>B;

// компоненты объекта С принимают значение max от А и В C.see();

i=A==B;

cout << A==B << endl;

// ошибка // error binary '<<' : no operator defined which takes a right-hand operand // of type 'class dek_koord' (or there is no acceptable conversion) cout << (A==B) << endl;

// верно } В приведенной выше программе функцию перегрузки оператора * можно изменить, например, следующим образом dek_koord &dek_koord::operator*(const dek_koord &a) {x*=a.x;

y*=a.y;

return *this;

} В этом примере функция operator в качестве параметра получает ссылку на объект, стоящий в правой части выражения А*В, то есть на В. Ссылка – это второе имя (псевдоним) для одного и того же объекта. Более подробно ссылки будут рассмотрены позже. Функция при вызове получает скрытый указатель на объект А и модифицирует неявные параметры (компоненты-данные объекта А – х и у). Возвращается значение по адресу this, то есть объект А.

Следует отметить, что если в описании класса dek_koord присутствуют объявления двух функций перегрузки операции *:

class dek_koord {...

dek_koord operator*(const dek_koord );

dek_koord &operator*(const dek_koord &);

...

};

то возникает ошибка.

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

Ниже приведен пример еще одной программы перегрузки оператора ”-“ для использования его при вычитании из одной строки другой.

#include #include class String { char str[80];

// локальная компонента public: // глобальные компоненты void init (char *s);

// функция инициализации int operator – (String s_new);

// прототип функции operator } my_string1, my_string2;

// описание двух объектов класса String void String::init (char *s) // ф-ция обеспечивает копирование строки- // аргумента(s) в строку-компоненту (str) { strcpy(str,s);

} // класса String int String::operator – (String s_new) // перегрузка оператора – (вычитания // строк) { for (int i=0;

str[i]==s_new.str[i];

i++) if (!str[i]) return 0;

return str[i] – s_new.str[i];

} void main(void) { char s1[51], s2[51];

cout <<"Введите первую строку не более 80 символов:" <

cin >>s1;

cout<<" Введите вторую строку не более 80 символов "<

cin>>s2;

my_string1.init(s1);

//инициализация объекта my_string my_string2.init(s2);

//инициализация объекта my_string cout <<"\nString1 – String2 = ";

// вывод на экран разности двух строк cout << my_string1 – my_string2 << endl;

} Результат работы программы:

Введите первую строку не более 80 символов:

overload Введите вторую строку не более 80 символов function String1 – String2 = При перегрузке бинарного оператора с использованием компоненты функции ей передается в качестве параметра только один аргумент. Второй ар гумент получается посредством использования неявного указателя this на объ ект, компоненты которого модифицируются.

Перегрузка унарного оператора При перегрузке унарной операции функция operator не имеет параметров.

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

Унарный оператор, как и бинарный, может быть перегружен двумя спо собами:

как компонента-функция без аргументов;

как глобальная функция с одним аргументом.

Как известно, унарный оператор может быть префиксным и постфикс ным. Для любого префиксного унарного оператора выражение #a может быть представлено при первом способе как a.operator#(), а при втором как #operator(a).

При перегрузке унарного оператора, используемого в постфиксной фор ме, выражение вида a# может быть представлено при первом способе как a.operator#(int) или как operator#(a,int) при втором способе. При этом аргу мент типа int не существует и используется для отличия префиксной и пост фиксной форм при перегрузке.

Ниже приведен пример программы перегрузки оператора ++ и реализа ции множественного присваивания. Для перегрузки унарного оператора ++, предшествующего оператору i++, вызывается функция operator ++(). В случае если оператор ++ следует за операндом, то вызывается функция operator++(int x), где х принимает значение 0.

#include "iostream.h" class dek_koord { int x,y;

// декартовы координаты точки public:

dek_koord(){};

dek_koord(int X,int Y): x(X),y(Y) {} void operator++();

void operator++(int);

dek_koord operator=(dek_koord);

void see();

};

void dek_koord::operator++() // перегрузка операции ++A { x++;

} void dek_koord::operator++(int) // перегрузка операции A++ { y++;

} dek_koord dek_koord::operator =(dek_koord a) { x=a.x;

// перегрузка операции = y=a.y;

return *this;

} void dek_koord::see() { cout << "координата х = " << x << endl;

cout << "координата y = " << y << endl;

} void main() { dek_koord A(1,2), B, C;

A.see();

A++;

// увеличение значения компоненты х объекта А A.see();

// просмотр содержимого объекта А ++A;

// увеличение значения компоненты у объекта А A.see();

// просмотр содержимого объекта А C=B=A;

// множественное присваивание B.see();

C.see();

} Результат работы программы:

координата х = координата y = координата х = координата y = координата х = координата y = координата х = координата y = координата х = координата y = Дружественная функция operator Функция operator может быть не только членом класса, но и friend функцией этого класса. Как было отмечено ранее, friend-функции, не являясь компонентами класса, не имеют неявного указателя this. Следовательно, при перегрузке унарных операторов в функцию operator передается один, а бинар ных – два аргумента. Необходимо отметить, что операторы: =, (), [] и -> не могут быть перегружены с помощью friend-функции operator.

#include "iostream.h" class dek_koord { int x,y;

// декартовы координаты точки public:

dek_koord(){};

dek_koord(int X,int Y): x(X),y(Y) {} friend dek_koord operator*(int,dek_koord);

friend dek_koord operator*(dek_koord,int);

dek_koord operator=(dek_koord);

void see();

};

dek_koord operator*(int k,dek_koord dk) // перегрузка операции A++ { dk.x*=k;

dk.y*=k;

return dk;

} dek_koord operator*(dek_koord dk,int k) { dk.x*=k;

dk.y*=k;

return dk;

} dek_koord dek_koord::operator=(dek_koord dk) { x=dk.x;

y=dk.y;

return *this;

} void dek_koord::see() { cout << "координата т.(х,y) = " << x<<’ ’ <

} void main() { dek_koord A(1,2), B;

A.see();

B=A*2;

// увеличение значения объекта А в 2 раза B.see();

// просмотр содержимого объекта B } Результат работы программы:

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

имя_класса (const имя_класса & );

Конструктор выполняет все необходимые действия при вызове функции и копировании содержимого объекта в стек (из стека). Вызов конструктора копи рования осуществляется при обращении к функции и передаче в нее в качестве параметра объекта (объектов), а также возврата значения (объекта) из функции.

#include "iostream.h" #include "string.h" class string { char *str;

// int size;

public:

string(){};

// конструктор по умолчанию string(int n,char *s) // конструктор с параметрами { str=new char[size=n>=(strlen(s)+1)? n : strlen(s)+1];

strcpy(str,s);

} string(const string &);

// конструктор копирования ~string(){};

// деструктор friend string operator+(string, const string);

string &operator=(const string &);

void see();

};

string::string(const string &a) // описание конструктора копирования { str=new char[a.size+1];

// выделяем память под this->str (+1 под ’\0’) strcpy(str,a.str);

// копирование строки size=strlen(str);

} string operator+(string s1, const string s2) // перегрузка операции + { string ss;

ss.str=new char[ss.size=strlen(s1.str)+strlen(s2.str)+1];

for(int i=0;

ss.str[i]=s1.str[i];

i++);

// перезапись символа ’\0’ ss.str[i]=' ';

// удаление ’\0’ for(int j=0;

ss.str[i+1]=s2.str[j];

i++,j++);

// дозапись второй строки return ss;

} string &string::operator =(const string &st) // перегрузка операции = { if(this!=&st) // проверка, не копирование ли объекта в себя { delete str;

// освобождаем память старой строки str=new char[size=st.size];

// выделяем память под новую строку strcpy(str,st.str);

} return *this;

} void string::see() { cout << this->str << endl;

} void main() { string s1(10,"язык"), s2(30,"программирования"), s3(30," ");

s1.see();

s2.see();

string s4=s1;

// это только вызов конструктора копирования s4.see();

s1+s2;

// перегрузка + (вызов функции operator +) s1.see();

s3=s2;

// перегрузка = (вызов функции operator =) s3.see();

s3=s1+s2;

//перегрузка операции +, затем операции = s3.see();

} Результаты работы программы:

язык программирования язык язык программирования язык программирования Инструкция string s4=s1 только вызывает конструктор копирования для объекта s4. Выполнение инструкции s1+s2 приводит к двум вызовам конструк тора копирования (вначале для копирования в стек объекта s2, затем s1). После этого выполняется вызов функции operator+ для инструкции s1+s2. При выходе из функции (инструкция return ss) вновь выполняется вызов конструктора ко пирования. При выполнении инструкции s3=s2 конструктор копирования для копирования объекта s2 в стек не вызывался, так как параметр в operator= пере дан (и возвращен) по ссылке.

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

Перегрузка оператора [] Как было отмечено выше, функция operator может быть с успехом ис пользована для доопределения операторов С++ (в основном арифметические, логические и операторы отношения). В то же время в С++ существуют некото рые операторы, не входящие в число перечисленных, но которые полезно пере гружать. К ним относится оператор []. Его необходимо перегружать с помощью компоненты-функции, использование friend-функции запрещено. Общая форма функции operator[]() имеет вид:

Тип_возвр_значения имя_класса::operator [](int i) { тело функции} Параметр функции необязательно должен иметь тип int, но он использо ван, так как operator[] в основном применяется для индексации. Рассмотрим пример программы, с использованием перегрузки операции []:

#include "iostream.h" class massiv { float f[3];

public:

massiv(float i,float j,float k){f[0]=i;

f[1]=j;

f[2]=k;

} float operator[](int i) { return f[i];

} // перегрузка оператора [] };

void main() { massiv ff(1,2,3);

double f;

int i;

cout << "введите номер индекса ";

cin >> i;

cout <<"f["<< i <<" ]= " << ff[i] << endl;

} В примере перегруженная функция operator[]() возвращает величину эле мента массива, индекс которого передан в функцию в качестве параметра. Дан ная программа при небольшой модификации может позволить использовать оператор[] как справа, так и слева от оператора присваивания. Для этого необ ходимо, чтобы функция operator[]() возвращала не элемент, а ссылку на него.

#include "iostream.h" class massiv { float f[3];

public:

massiv(float i,float j,float k){f[0]=i;

f[1]=j;

f[2]=k;

} float &operator[](int i) // перегрузка оператора [] { if(i<0 || i>2) // проверка на выход за границы массива { cout << “Выход за пределы массива”<

exit(1);

} return f[i];

} };

void main() { massiv ff(1,2,3);

double f;

int i;

cout << "введите номер индекса ";

cin >> i;

cout <<"f["<< i <<" ]= " << ff[i] << endl;

ff[i]=5;

// если функция operator не возвращает ссылку,то компилятор // выдает ошибку =' : left operand must be l-value cout <<"f["<< i <<" ]= " << ff[i] << endl;

} Приведем еще один пример программы, использующей перегрузку operator[].

// перегрузка функции operator[] на примере вычисления n!

#include "iostream.h" #include "values.h" // для определения константы MAXLONG class fact { long l;

public:

long operator[](int);

// перегрузка оператора [] };

long fact::operator[](int n) { long l;

for (int i=0;

i<=n;

i++) //выбор буквы из уменьшаемой строки if(l>MAXLONG/i) cerr<<"ОШИБКА факториал числа "<

else l*=i;

return l;

} void main() { fact f;

int i,k;

cout << "введите число k для нахождения факториала" cin >> k;

for (i=1;

i<=k;

i++) cout << i <<"! = " << f[i] << endl;

} Перегрузка оператора () Оператор вызова функции можно доопределить, как и любой другой опе ратор. Как и в предыдущем случае, оператор () необходимо перегружать только с помощью компоненты-функции, использование friend-функции запрещено.

Общая форма функции operator()() имеет вид:

тип_возвр_значения имя_класса::operator ()(список_аргументов) { тело функции} #include "iostream.h" class matr { int **m,a,b;

public:

matr(int,int);

~matr();

int operator()(int,int);

// перегрузка оператора () int operator()(int);

// перегрузка оператора () };

matr::matr(int i,int j): a(i),b(j) // конструктор { i=0;

m=new int *[a];

for(int k=0;

k

k++) { *(m+k)=new int[b];

for(int n=0;

n

n++) *(*(m+k)+n)=i++;

// заполнение m числами 0, 1, 2, 3, …, a*b } } matr::~matr() // деструктор { for(int k=0;

k

k++) delete [] m[k];

// освобождение памяти для k-й строки delete [] m;

// освобождение памяти для всего массива } // указателей m int matr::operator()(int i,int j) { if (i<0 || i>=a || j<0 || j>=b) { cerr<<"выход за пределы матрицы ";

return m[0][0];

// например, при этом возврат m[0][0] } return m[i][j];

// возврат требуемого элемента } int matr::operator()(int i) { if (i<0 || i>=a*b) { cerr<<"выход за пределы массива ";

return **m;

// как и выше возврат m[0][0] } return m[i/b][i%b];

// возврат требуемого элемента } void main() { matr mt(3,5);

cout << mt(2,3) << endl;

cout << mt(3,2) << endl;

// попытка получить элемент из 3-й строки cout << mt(3) << endl;

} Результаты работы программы:

выход за пределы массива Конструктор класса matr динамически выделяет и инициализирует память двухмерного массива. Деструктор разрушает массив автоматически при завер шении программы. В классе matr реализованы две функции operator(): первая получает два аргумента (индексы в матрице), вторая получает один аргумент (порядковый номер элемента в матрице). Обе функции возвращают либо тре буемый элемент, либо элемент m[0][0] при попытке выхода за пределы матри цы.

Перегрузка оператора -> Оператор -> доступа к компонентам объекта через указатель на него оп ределяется как унарный постфиксный.

Ниже приведен простой пример программы перегрузки оператора ->:

#include "iostream.h" #include "iomanip.h" #include "string.h" class cls_A { char a[40];

public:

int b;

cls_A(char *aa,int bb): b(bb) // конструктор {strcpy(a,aa);

} char *put_A() {return a;

} };

class cls_B { cls_A *p;

// указатель на класс cls_A public:

cls_B(char *aa,int bb) {p=new cls_A(aa,bb);

} // конструктор ~cls_B() {delete p;

} // деструктор cls_A *operator->(){return p;

} // функция перегрузки -> };

void main() { cls_B ptr("перегрузка оператора -> ",2);

// объект класса cls_B cout << ptr->put_A() << setw(6) << ptr->b <

// перегрузка -> cout << (ptr.operator->())->put_A() << setw(6) << (ptr.operator->())->b <

cout << (*ptr.operator->()).put_A() << setw(6) << (*ptr.operator->()).b <

} Результат работы программы:

перегрузка оператора -> перегрузка оператора -> перегрузка оператора -> В приведенной программе инструкции ptr->put_A() и ptr->b приводят к перегрузке операции ->, то есть позволяют получить адрес указателя на компо ненты класса cls_A для (из) объекта ptr. Таким образом, инструкция ptr->b со ответствует инструкции (ptr.p)->b. Следующие далее две группы инструкций также верны, но не являются примером перегрузки оператора ->, а только при водят к явному вызову функции operator-> – компоненты класса cls_B.

В целом доопределение оператора -> позволяет использовать ptr, с одной стороны, как специальный указатель (в примере для класса cls_A), а с другой стороны, как объект (для класса cls_B).

Специальные указатели могут быть доопредены следующим образом:

cls_A &operator*(){return *p;

} cls_A &operator[](int index){return p[index];

} а также доопределение может быть выполнено по отношению к большинству рассмотренных ранее операций (+, ++ и др.).

Перегрузка операторов new и delete В С++ имеются две возможности перегрузки операторов new и delete – локально (в пределах класса) и глобально (в пределах программы). Эти операто ры имеют правила переопределения, отличные от рассмотренных выше правил переопределения других операторов. Одна из причин перегрузки операторов new и delete состоит в том, чтобы придать им новые свойства, например, выда чи диагностики или более высокой защищенности от ошибок. Кроме того, мо жет быть реализована более эффективная схема распределения памяти по срав нению со схемой, обеспечиваемой системой.

Оператор new можно задать в следующих формах:

<::> new <аргументы> имя_типа <инициализирующее_выражение> <::> new <аргументы> имя_типа [ ] Параметр “аргументы” можно использовать либо для того, чтобы разли чить разные версии глобальных операторов new, либо для использования их в теле функции operator. Доопределенную функцию operator new можно объя вить:

void *operator new(size_t t<список _аргументов>);

void *operator new[](size_t t<список _аргументов>);

Вторая форма используется для выделения памяти для массивов. Возвра щаемое значение всегда должно иметь тип void *. Единственный обязательный аргумент функции operator всегда должен иметь тип size_t. При этом в функ цию operator автоматически подставляется аргумент sizeof(t).

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

#include "iostream.h" #include "string.h" void *operator new(size_t tip,int kol) //глобальная ф-ция operator new { cout << "глобальная функция 1" <

// с одним параметром return new char[tip*kol];

} void *operator new(size_t tip,int n1,int n2) //глобальная ф-ция operator new { cout << "глобальная функция 2" <

// с двумя параметрами void *p=new char[tip*n1*n2];

return p;

} class cls { char a[40];

public:

cls(char *aa){ strcpy(a,aa);

} ~cls(){} void *operator new(size_t,int);

};

void *cls::operator new(size_t tp,int n) // локальная функция operator { cout << "локальная функция " <

return new char[tp*n];

} void main() { cls obj("перегрузка оператора new");

float *ptr1;

ptr1=new (5) float;

// вызов 1 глобальной функции operator new ptr1=new (2,3) float;

// вызов 2 глобальной функции operator new ptr1=new float;

// вызов сиcтемной глобальной функции cls *ptr2=new (3) cls("aa");

// вызов локальной функции operator new } // используя cls::cls("aa") Результаты работы программы:

глобальная функция глобальная функция локальная функция Первое обращение ptr1=new (5) float приводит к вызову глобальной функции operator с одним параметром, в результате выделяется память 5*sizeof(float) байт (это соответствует массиву из 5 элементов типа float) и ад рес заносится в указатель ptr1. Второе обращение приводит к вызову функции operator с двумя параметрами. Следующая инструкция new float приводит к вы зову системной функции new. Инструкция new (3) cls("aa") соответствует вызо ву функции operator, описанной в классе cls. В функцию в качестве имени типа передается тип созданного объекта класса cls. Таким образом, ptr2 получает ад рес массива из 3 объектов класса cls.

Оператор delete разрешается доопределять только по отношению к клас су. В то же время можно заменить системную версию реализации оператора delete на свою.

Доопределенную функцию operator delete можно объявить:

void *operator delete(void *p<,size_t t>);

void *operator delete[](void *p<,size_t t>);

Функция operator должна возвращать значение void и имеет один обяза тельный аргумент типа void * – указатель на память, которая должна быть ос вобождена. Ниже приведен пример программы с доопределением оператора delete.

#include "iostream.h" #include "string.h" #include "stdlib.h" void *operator new(size_t tip,int kol) // глобальная функция operator { cout << "глобальная функция NEW" <

return new char[tip*kol];

} class cls { char a[40];

public:

cls(char *aa) { cout<<”работает конструктор”<

strcpy(a,aa);

} ~cls(){} void *operator new(size_t,int);

void operator delete(void *);

};

void *cls::operator new(size_t tip,int n) // локальная функция operator { cout << "локальная функция " <

return new char[tip*n];

} void cls::operator delete(void *p) // локальная функция operator { cout << "локальная функция DELETE" <

delete p;

// вызов системной функции delete } void operator deleteх[](void *p) // глобальная функция operator { cout << "глобальная функция DELETE" <

delete p;

// вызов системной функции delete } void main() { cls obj("перегрузка операторов NEW и DELETE");

float *ptr1;

ptr1=new (5) float;

// вызов глобальной ф-ции доопр. оператора new delete [] ptr1;

// вызов глобальной ф-ции доопр.оператора delete cls *ptr2=new (10) cls("aa");

// вызов локальной функции доопределения // оператора new (из класса cls) delete ptr2;

// вызов локальной функции доопределения // оператора delete (из класса cls) } Результаты работы программы:

глобальная функция NEW работает конструктор глобальная функция DELETE локальная функция NEW локальная функция DELETE Инструкция cls *ptr2=new (10) cls("aa") выполняется следующим образом:

вначале вызывается локальная функция operator для выделения памяти, равной 10*sizeof(cls), затем вызывается конструктор класса cls.

Необходимо отметить тот факт, что при реализации переопределения глобальной функции в ней не должен использоваться оператор delete [], так как это приведет к бесконечной рекурсии. При выполнении инструкции системный оператор delete ptr2 сначала вызывается локальная функция доопределения оператора delete для класса cls, а затем из нее глобальная функция переопреде ления delete.

Далее рассмотрим пример доопределения функций new и delete в одном из классов, содержащемся в некоторой иерархии классов.

#include "iostream.h" class A { public:

A(){} virtual ~A(){} void *operator new(size_t,int);

void operator delete(void *,size_t);

};

class B : public A { public:

B(){} ~B(){} };

void *A::operator new(size_t tip,int n) { cout << "перегрузка operator NEW" <

return new char[tip*n];

} void A::operator delete(void *p,size_t t) //глобальная функция operator { cout << " перегрузка operator DELETE" <

delete p;

// вызов глобальной (системной функции) } void main() { A *ptr1=new(2) A;

// вызов локальной функции, используя A::A() delete ptr1;

A *ptr2=new(3) B;

// вызов локальной функции, используя B::B() delete ptr2;

} Результаты работы программы:

перегрузка operator NEW перегрузка operator DELETE перегрузка operator NEW перегрузка operator DELETE Преобразование типа Выражения, содержащиеся в функциях и используемые для вычисления некоторого значения, записываются в большинстве случаев с учетом коррект ности по отношению к объектам этого выражения. В то же время, если исполь зуемая операция для типов величин, участвующих в выражении, явно не опре делена, то компилятор пытается выполнить такое преобразование типов в два этапа.

На первом этапе выполняется попытка использовать стандартные преоб разования типов. Если это невозможно, то компилятор использует преобразо вания, определенные пользователем.

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

int a = (int) b;

char *s=(char *) addr;

Недостатком их является полное отсутствие контроля, что приводит к ошибкам и путанице. Этого можно избежать в С++. Для преобразования с ми нимальным контролем можно использовать операцию staic_cast.

static_cast<тип> (выражение) Она позволяет выполнять преобразования, не проверяя типы выражений во время выполнения, а основываясь на сведениях, полученных при компиля ции. Операция static_cast позволяет выполнять преобразования не только указа теля на базовый класс к указателю на производный, но и наоборот.

В то же время преобразование int к int* приведет к ошибке компиляции.

Для преобразований не связанных между собой типов используется reinterpret_cast.

int i;

void *addr= reinterpret_cast i;

Если же нужно выполнить преобразование неизменяемого типа к изме няемому, то можно использовать const_cast:

const char *s char ss=const_cast s;

Преобразования типов, определенных в программе Конструктор с одним аргументом можно явно не вызывать.

#include "iostream.h" class my_class { double x,y;

// public:

my_class(double X){x=X;

y=x/3;

} double summa();

};

double my_class::summa() { return x+y;

} void main() { double d;

my_class my_obj1(15), // создание объекта obj1 и инициализация его my_obj2=my_class(15), // создание объекта obj2 и инициализация его my_obj3=15;

// создание объекта obj3 и инициализация его d=my_obj1;

// error no operator defined which takes a right-hand operand of // type 'class my_class' (or there is no acceptable conversion) cout << my_obj1.summa() << endl;

cout << my_obj2.summa() << endl;

cout << my_obj3.summa() << endl;

} В рассматриваемом примере все три создаваемых объекта будут инициа лизированы числом 15 (первые два явным, третий неявным вызовом конструк тора). Следовательно, значение базовой переменной (определенной в языке) может быть присвоено переменной типа, определенного пользователем.

Для выполнения обратных преобразований, то есть от переменных, имеющих тип, определенный пользователем к базовому типу, можно задать преобразования с помощью соответствующей функции operator(), например:

class my_class { double x,y;

public:

operator double() {return x;

} my_class(double X){x=X;

y=x/3;

} double summa();

};

Теперь в выражении d=my_obj1 не будет ошибки, так как мы задали прямое преобразование типа. При выполнении этой инструкции активизируется функция operator, преобразующая значение объекта к типу double и возвра щающая значение компоненты объекта. Наряду с прямым преобразованием в С++ имеется подразумеваемое преобразование типа:

#include "iostream.h" class my_cl { double x;

// public:

operator double(){return x;

} my_cl1(double X) : x(X) {} };

class my_cl { double x;

// public:

operator double(){return x;

} my_cl2(my_cl1 XX): x(XX) {} };

void fun(my_cl2 YY) { cout << YY <

} void main() { fun(12);

// ERROR cannot convert parameter // from 'const int' to 'class my_cl2' fun(my_cl2(12));

// подразумеваемое преобразование типа } В этом случае для инструкции fun(my_cl2(12)) выполняется следующее:

активизируется конструктор класса my_cl1 (x инициализируется значени ем 12);

при выполнении в конструкторе my_cl2 инструкции x(XX) вызывается функция operator (класса my_cl1), возвращающая значение переменной x, пре образованное к типу double;

далее при выполнении инструкции cout << YY вызывается функция operator() класса my_cl2, выполняющая преобразование значения объекта YY к типу double.

Разрешается выполнять только одноуровневые подразумеваемые преоб разования. В приведенном выше примере инструкция fun(12) соответствует двухуровневому неявному преобразованию, где первый уровень – my_cl1(12) и второй – my_cl2(my_cl1(12)) В заключение отметим основные правила доопределения операторов:

– все операторы языка С++ за исключением. * :: ?: sizeof и символов # ## можно доопределять;

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

– количество операндов, которыми оперируют операторы (унарные, би нарные), и приоритет операций сохраняются и для доопределенных операторов.

Шаблоны Параметризированные классы Параметризированный класс – некоторый шаблон, на основе которого можно строить другие классы. Этот класс можно рассматривать как некоторое описание множества классов, отличающихся только типами их данных. В С++ используется ключевое слово template для обеспечения параметрического по лиморфизма. Параметрический полиморфизм позволяет использовать один и тот же код относительно различных типов (параметров тела кода). Это наибо лее полезно при определении контейнерных классов. Шаблоны определения класса и шаблоны определения функции позволяют многократно использовать код, корректно по отношению к различным типам, позволяя компилятору авто матизировать процесс реализации типа.

Шаблон класса определяет правила построения каждого отдельного клас са из некоторого множества разрешенных классов.

Спецификация шаблона класса имеет вид:

template <список параметров> class объявление класса Список параметров класса-шаблона представляет собой идентификатор типа, подставляемого в объявление данного класса при его генерации. Рассмот рим пример шаблона класса работы с динамическим массивом и выполнением контроля за значениями индекса при обращении к его элементам.

#include "iostream.h" #include "string.h" template class vector { T *ms;

int size;

public:

vector() : size(0),ms(NULL) {} ~vector(){delete [] ms;

} void inkrem(const T &t) // увеличение размера массива на 1 элемент { T *tmp = ms;

ms=new T[size+1];

// ms – указатель на новый массив if(tmp) memcpy(ms,tmp,sizeof(T)*size);

// перезапись tmp -> ms ms[size++]=t;

// добавление нового элемента if(tmp) delete [] tmp;

// удаление временного массива } void decrem(void) // уменьшение размера массива на 1 элемент { T *tmp = ms;

if(size>1) ms=new T[--size];

if(tmp) { memcpy(ms,tmp,sizeof(T)*size);

// перезапись без посл.элемента delete [] tmp;

// удаление временного массива } } T &operator[](int ind) // определение обычного метода { // if(ind<0 || (ind>=size)) throw IndexOutOfRange;

// возбуждение // исключительной ситуации IndexOutOfRange return ms[ind];

} };

void main() { vector VectInt;

vector VectDouble;

VectInt. inkrem(3);

VectInt. Inkrem(26);

VectInt. inkrem(12);

// получен int-вектор из 3 атрибутов VectDouble. inkrem(1.2);

VectDouble. inkrem(.26);

//получен double-вектор из 2 атрибутов int a=VectInt[1];

// a = ms[1] cout << a << endl;

int b=VectInt[4];

// будет возбуждена исключительная ситуация cout << b << endl;

double d=VectDouble[0];

cout << d << endl;

VectInt[0]=1;

VectDouble[1]=2.41;

} Класс vector наряду с конструктором и деструктором имеет 2 функции:

decrem – добавление в конец вектора нового элемента, inkrem – уменьшение числа элементов на единицу и операция [] обращения к i-му элементу вектора.

Параметр шаблона vector – любой тип, у которого определены операция присваивания и операция new. Например, при задании объекта типа vector происходит генерация конкретного класса из шаблона и конструирование соот ветствующего объекта VectInt, при этом тип Т получает значение типа int. Ге нерация конкретного класса означает, что генерируются все его компоненты функции, что может привести к существенному увеличению кода программы.

Выполнение функций VectInt.decrem(3);

VectInt.decrem(26);

VectInt.decrem(12);

приведет к созданию вектора (массива) из трех атрибутов (3, 26 и 12 ).

Сгенерировать конкретный класс из шаблона можно, явно записав:

template vector;

При этом не будет создано никаких объектов типа vector, но будет сгенерирован класс со всеми его компонентами.

В некоторых случаях желательно описания некоторых компонент функций шаблона класса выполнить вне тела шаблона, например:

#include "iostream.h" template T1 sm1(T1 aa,T2 bb) // описание шаблона глобальной { return (T1)(aa+bb);

// функции суммирования значений } // двух аргументов template class cls { T1 a;

T2 b;

public:

cls(T1 A,T2 B) : a(A),b(B) {} ~cls(){} T1 sm1() // описание шаблона функции { return (T1)(a+b);

// суммирования компонент объекта obj_ } T1 sm2(T1,T2);

// объявление шаблона функции };

template T1 cls::sm2(T1 aa,T2 bb) // описание шаблона функции { return (T1)(aa+bb);

// суммирования внешних данных } void main() { cls obj1(3,4);

cls obj2(.3,.4);

cout<<"функция суммирования компонент объекта 1 = " <

cout<<"функция суммирования внешних данных (int,int) = " <

cout<<"вызов глобальной функции суммирования (int,int) = " <

cout<<"функция суммирования компонент объекта 2 = " <

cout<<"функция суммирования внешних данных (double,double)= " <

} Передача в шаблон класса дополнительных параметров При создании экземпляра класса из шаблона в него могут быть переданы не только типы, но и переменные и константные выражения:

#include "iostream.h" template class cls { T1 a;

T2 b;

public:

cls(T1 A,T2 B) : a(A),b(B){} ~cls(){} T1 sm() //описание шаблона ф-ции суммирования компонент объекта { // i+=3;

// error member function 'int thiscall cls::sm(void)' return (T1)(a+b+i);

} };

void main() { cls obj1(3,2);

// в шаблоне const i инициализируется cls obj2(3,2,1);

// error 'cls::cls':no overloaded // function takes 3 parameter s cls obj13(3,2,1);

// error 'cls' : invalid template argument for 'i', // constant expression expected cout<

} Результатом работы программы будет выведенное на экран число 6.

В этой программе инструкция template гово рит о том, что шаблон класса cls имеет три параметра, два из которых – имена типов (Т1 и Т2), а третий (int i=0) – целочисленная константа. Значение кон станты i может быть изменено при описании объекта cls obj1(3,2).

Шаблоны функций В С++, так же как и для класса, для функции (глобальной, то есть не яв ляющейся компонентой-функцией) может быть описан шаблон. Это позволит снять достаточно жесткие ограничения, накладываемые механизмом формаль ных и фактических параметров при вызове функции. Рассмотрим это на приме ре функции, вычисляющей сумму нескольких аргументов.

#include "iostream.h" #include "string.h" template T1 sm(T1 a,T2 b) // описание шаблона { return (T1)(a+b);

// функции c 2 параметрами } template T1 sm(T1 a,T2 b,T3 c) // описание шаблона функции { return (T1)(a+b+c);

// функции c 3 параметрами } void main() {cout<<"вызов ф-ции суммирования sm(int,int) = "<

cout<<"вызов ф-ции суммирования sm(int,int,int) = "<

cout<<"вызов ф-ции суммирования sm(int,double) = "<

cout<<"вызов ф-ции суммирования sm(double,int,short)= " << sm(.4,6,(short)1)<

// cout<

error cannot add two pointers } В программе описана перегруженная функция sm(), первый экземпляр ко торой имеет 2, а второй 3 параметра. При этом тип формальных параметров функции определяется при вызове функции типом ее фактических параметров.

Используемые типы Т1, Т2, Т3 заданы как параметры для функции с помощью выражения template . Это выражение предполагает использование типов Т1, Т2 и Т3 в виде ее дополнительных параметров. Ре зультат работы программы будет иметь вид:

вызов функции суммирования sm(int,int) = вызов функции суммирования sm(int,int,int) = вызов функции суммирования sm(int,double) = вызов функции суммирования sm(double,int,short)= 7. В случае попытки передачи в функцию sm() двух строк, то есть типов, для которых не определена данная операция, компилятор выдаст ошибку. Что бы избежать этого, можно ограничить использование шаблона функции sm(), описав явным образом функцию sm() для некоторых конкретных типов данных.

В нашем случае:

char *sm(char *a,char *b) // явное описание функции объединения { char *tmp=a;

// двух строк a=new char[strlen(a)+strlen(b)+1];

strcpy(a,tmp);

strcat(a,b);

return a;

} Добавление в main() инструкции, например, cout<

приведет к выводу, кроме указанных выше, сообщения:

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

Только при обращении к функции с аргументами конкретного типа происходит генерация конкретной функции.

Совместное использование шаблонов и наследования Шаблонные классы, как и обычные, могут использоваться повторно.

Шаблоны и наследование представляют собой механизмы повторного исполь зования кода и могут включать полиморфизм. Шаблоны и наследования связа ны между собой следующим образом:

– шаблон класса может быть порожден от обычного класса;

– шаблонный класс может быть производным от шаблонного класса;

– обычный класс может быть производным от шаблона класса.

Ниже приведен пример простой программы, демонстрирующей наследо вание шаблонного класса oper от шаблонного класса vect.

#include "iostream.h" template class vect // класс-вектор {protected:

T *ms;

// массив-вектор int size;

// размерность массива-вектора public:

vect(int n) : size(n) // конструктор { ms=new T[size];

} ~vect(){delete [] ms;

} // деструктор T &operator[](const int ind) // доопределение операции [] { if((ind>0) && (ind

else return ms[0];

} };

template class oper : public vect // класс операций над вектором { public:

oper(int n): vect(n) {} // конструктор ~oper(){} // деструктор void print() // функция вывода содержимого вектора { for(int i=0;

i

i++) cout<

cout<

} };

void main() { oper v_i(4);

// int-вектор oper v_d(4);

// double-вектор v_i[0]=5;

v_i[1]=3;

v_i[2]=2;

v_i[3]=4;

// инициализация int v_d[0]=1.3;

v_d[1]=5.1;

v_d[2]=.5;

v_d[3]=3.5;

// инициализация double cout<<"int вектор = ";

v_i.print();

cout<<"double вектор = ";

v_d.print();

} Как следует из примера, реализация производного класса от класса- шаблона в основном ничем не отличается от обычного наследования.

Некоторые примеры использования шаблона класса При использовании в программе указателя на объект, память для которо го выделена с помощью оператора new, в случае если объект становится не ну жен, то для его разрушения необходимо явно вызвать оператор delete. В то же время на один объект могут ссылаться множество указателей и, следовательно, нельзя однозначно сказать, нужен ли еще этот объект или он уже может быть уничтожен. Рассмотрим пример реализации класса, для которого происходит уничтожение объектов, в случае если уничтожается последняя ссылка на него.

Это достигается тем, что наряду с указателем на объект хранится счетчик числа других указателей на этот же объект. Объект может быть уничтожен только в том случае, если счетчик ссылок станет равным нулю.

#include "iostream.h" #include "string.h" template struct Status // состояние указателя { T *RealPtr;

// указатель int Count;

// счетчик числа ссылок на указатель };

template class Point // класс-указатель { Status *StatPtr;

public:

Point(T *ptr=0);

// конструктор Point(const Point &);

// копирующий конструктор ~Point();

Point &operator=(const Point &);

// перегрузка // Point &operator=(T *ptr);

// перегрузка T *operator->() const;

T &operator*() const;

};

Приведенный ниже конструктор Point инициализирует объект указателем.

Если указатель равен NULL, то указатель на структуру Status, содержащую ука затель на объект и счетчик других указателей, устанавливается в NULL. В про тивном случае создается структура Status template Point::Point(T *ptr) // описание конструктора { if(!ptr) StatPtr=NULL;

else { StatPtr=new Status;

StatPtr->RealPtr=ptr;

StatPtr->Count=1;

} } Копирующий конструктор StatPtr не выполняет задачу копирования ис ходного объекта, а так как новый указатель ссылается на тот же объект, то мы лишь увеличиваем число ссылок на объект.

template // описание конструктора копирования Point::Point(const Point &p):StatPtr(p.StatPtr) { if(StatPtr) StatPtr->Count++;

// увеличено число ссылок } Деструктор уменьшает число ссылок на объект на 1, и при достижении значения 0 объект уничтожается template Point::~Point() // описание деструктора { if(StatPtr) { StatPtr->Count--;

// уменьшается число ссылок на объект if(StatPtr->Count<=0) // если число ссылок на объект <=0, { delete StatPtr->RealPtr;

// то уничтожается объект delete StatPtr;

} } } template T *Point::operator->() const { if(StatPtr) return StatPtr->RealPtr;

else return NULL;

} template T &Point::operator*() const // доступ к StatPtr осуществляется { if(StatPtr) return *StatPtr->RealPtr;

// посредством this-указателя else throw bad_pointer;

// исключительная ситуация } При выполнении присваивания вначале необходимо указателю слева от знака = отсоединиться от ”своего” объекта и присоединиться к объекту, на ко торый указывает указатель справа от знака =.

template Point &Point::operator=(const Point &p) { // отсоединение объекта справа от = от указателя if(StatPtr) { StatPtr->Count--;

if(StatPtr->Count<=0) // так же, как и в деструкторе { delete StatPtr->RealPtr;

// освобождение выделенной под объект delete StatPtr;

// динамической памяти } } // присоединение к новому указателю StatPtr=p.StatPtr;

if(StatPtr) StatPtr->Count++;

return *this;

} struct Str { int a;

char c;

};

void main() { Point pt1(new Str);

// генерация класса Point, конструирование // объекта pt1, инициализируемого указателем // на стр-ру Str, далее с объектом можно обра- // щаться как с указателем Point pt2=pt1,pt3;

// для pt2 вызывается конструктор копирования, // затем создается указатель pt pt3=pt1;

// pt3 переназначается на объект указателя pt (*pt1).a=12;

// operator*() получает this указатель на pt (*pt1).c='b';

int X=pt1->a;

// operator->() получает this-указатель на pt char C=pt1->c;

} Задание свойств класса Если в функцию сортировки числовой информации, принадлежащей не которому классу, передавать символьные строки (char *), то желаемый резуль тат (отсортированные строки) не будет получен. Как известно, в этом случае произойдет сравнение указателей, а не строк.

#include "iostream.h" #include "string.h" #include "typeinfo.h" class CompareNumb { public:

static bool sravn(int a, int b){return a

} };

class CompareString { public:

static bool sravn(char *a, char *b){return strcmp(a,b)<0;

} };

template class vect { T *ms;

int size;

public:

vect(int SIZE):size(SIZE) { ms=new T[size];

const type_info & t=typeid(T);

// получение ссылки t на const char* s=t.name();

// объект класса type_info for(int i=0;

i

i++) // в описании типа if(!strcmp(s,"char *")) cin >> (*(ms+i)=(T)new char[20]);

// ввод символьных строк else cin >> *(ms+i);

// ввод числовой информации } void sort_vec(vect &);

};

template void vect::sort_vec(vect &vec) { for(int i=0;

i

i++) for(int j=i;

j

j++) if(Compare::sravn(ms[i],ms[j])) { T tmp=ms[i];

ms[i]=ms[j];

ms[j]=tmp;

} for(i=0;

i

i++) cout << *(ms+i) << endl;

};

Класс Compare должен содержать логическую функцию sravn(), сравни вающую два значения типа Т.

void main() { vect vec1(3);

vec1.sort_vec(vec1);

vect vec2(3);

vec2.sort_vec(vec2);

} Нетрудно заметить, что для всех типов, для которых операция меньше (<) имеет нужный смысл, можно написать следующий шаблон класса сравнения.

template class Compare { public:

static bool sravn(T a, T b) { const type_info & t=typeid(T);

// получение ссылки t на const char* s=t.name();

// объект класса type_info if(!strcmp(s,"char *")) return strcmp((char *)a,(char *)b)<0;

else return a

} };

template class vect { T *ms;

int size;

public:

vect(int SIZE):size(SIZE) { ms=new T[size];

const type_info & t=typeid(T);

// получение ссылки t на const char* s=t.name();

// объект класса type_info for(int i=0;

i

i++) // в описании типа if(!strcmp(s,"char *")) cin >> (*(ms+i)=(T)new char[20]);

// ввод символьных строк else cin >> *(ms+i);

// ввод числовой информации } void sort_vec(vect &);

};

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

template > void vect::sort_vec(vect &vec) { for(int i=0;

i

i++) for(int j=i;

j

j++) if(C::sravn(ms[i],ms[j])) { T tmp=ms[i];

ms[i]=ms[j];

ms[j]=tmp;

} for(i=0;

i

i++) cout << *(ms+i) << endl;

};

void main() { vect > vec1(3);

vec1.sort_vec(vec1);

vect > vec2(3);

vec2.sort_vec(vec2);

vect > vec3(3);

vec3.sort_vec(vec3);

} В инструкции vect > vec1(3) содержится пробел между угловыми скобками. При его отсутствии компилятор спутает >> с операцией >> (сдвига).

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

Пространства имен используются для разделения глобального простран ства имен, что позволяет уменьшить количество конфликтов. Синтаксис про странства имен некоторым образом напоминает синтаксис структур и классов.

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

namespace NAME { int a;

doudle b;

char *fun(char *,int);

class CLS {...

public:

...

} } Далее, если обращение к элементам пространства имен производится вне контекста, его имя должно быть полностью квалифицировано, используя ::

NAME::b=2;

NAME:: fun(str,NAME:: a);

Внутри пространства имен можно поместить группу объявлений классов, типов и функций. Реализация функций пространства имен должна находиться вне самого пространства имен. Это позволит не только отделить реализацию функций от их объявления, но и избежать загромождения пространства имен.

По существу, namespace определяет область видимости.

Использование безымянного пространства имен (отсутствует имя про странства имен) позволяет определить уникальность объявленных в нем иден тификаторов с областью видимости в пределах файла.

Контексты пространства имен могут быть вложены.

namespace NAME { int a;

namespace NAME { int a;

int fun1(){return NAME1:: a};

// возвращается значение первого a int fun2(){return a};

// возвращается значение второго a } } NAME!::NAME2::fun1();

// вызов функции Если в каком-то месте программы интенсивно используется некоторый контекст и все имена уникальны по отношению к нему, то можно сократить полные имена, объявив контекст текущим с помощью оператора using.

Если элементы пространства имен будут интенсивно использоваться, то можно использовать ключевое слово using для упрощения доступа к ним.

Ключевое слово using используется и как директива, и для объявления.

Синтаксис слова using определяет, является ли оно директивой или объявлением.

Ключевое слово using как директива Директива using namespace имя позволяет предоставить все имена, объ явленные в пространстве имен, для доступа в текущей области действия. Это позволит обращаться к этим именам без указания их полного имени, включаю щего название пространства имен.

#include namespace NAME { int n1=1;

int n2=2;

} // int n1;

приводит к неоднозначности в main для переменной n int main() { NAME::n1=3;

// n1=3;

// error 'n1' : undeclared identifier // n2=4;

// error 'n2' : undeclared identifier using namespace NAME;

// далее n1 и n2 доступны n2=4;

cout << n1 <<" "<< n2 << endl;

// результат 3 { n1=5;

n2=6;

cout << n1 <<" "<< n2 << endl;

// результат 5 } return 0;

} В результате выполнения программы получим:

3 5 Область действия директивы using распространяется на блок, в котором она использована, и на все вложенные блоки.

Если одно из имен относится к глобальной области, а другое объявлено внутри пространства имен, то возникает неоднозначность. Это проявится толь ко при использовании этого имени, а не при объявлении.

Ключевое слово using как объявление Объявление using имя::член подобно директиве, при этом оно обеспечи вает более подробный уровень управления. Обычно using используется для объявления некоторого имени (из пространства имен) как принадлежащего те кущей области действия (блоку).

#include namespace NAME { int n1=1;

int n2=2;

} int main() { NAME::n1=3;

// n1=4;

error 'n1' надо указывать полностью NAME::n // n2=5;

error 'n2' : undeclared identifier // int n2;

следующая строка приводит к ошибке using NAME::n2;

// далее n2 доступно n2=6;

cout <

// результат 3 { NAME::n1=7;

n2=8;

cout <

// результат 7 } return 1;

} В результате выполнения программы получим:

3 7 Объявление using добавляет определенное имя в текущую область дейст вия. В примере к переменной n2 можно обращаться без указания принадлежно сти классу, а для n1 необходимо полное имя. Объявление using обеспечивает более подробное управление именами, переносимыми в пространство имен.

Это и есть ее основное отличие от директивы, которая переносит все имена пространства имен.

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

Псевдоним пространства имен Псевдоним пространства имен существует для того, чтобы назначить дру гое имя именованному пространству имен.

namespace spisok_name_peremen // пространство имен { int n1=1;

...

} NAME = spisok_name_peremen;

// псевдоним пространства имен Пространству имен spisok_name_peremen назначается псевдоним NAME.

В этом случае результат выполнения инструкций:

cout <

cout<< spisok_name_peremen::n1<

будет одинаков.

Организация ввода-вывода Системы ввода-вывода С и С++ основываются на понятии потока. Поток в С++ это абстрактное понятие, относящееся к переносу информации от источ ника к приемнику. В языке С++ реализованы 2 иерархии классов, обеспечи вающих операции ввода-вывода, базовыми классами которых являются streambuf и ios. На рис.6 приведена диаграмма классов, базовым для которых является ios (рис. 6).

ios istream fstreambase strstreambase ostream ifstream istrstream ofstream ostrstream iostream fstream strstream Рис. 6. Диаграмма наследования класса ios В С++ используется достаточно гибкий способ выполнения операций ввода-вывода классов с помощью перегрузки операторов << (вывода) и >> (ввода). Операторы, перегружающие эти операции, обычно называют инсерте ром и экстрактором. Для обеспечения работы с потоками ввода-вывода необ ходимо включить файл iostream.h, содержащий класс iostream. Этот класс явля ется производным от ряда классов, таких как ostream, обеспечивающего вывод данных в поток, и istream – соответственно чтения из потока. Приводимый ни же пример показывает, как можно перегрузить оператор ввода-вывода для про извольных классов.

#include "iostream.h" class cls { char c;

short i;

public :

cls(char C,short I ) : c(C), i(I){} ~cls(){} friend ostream &operator<<(ostream &,const cls);

friend istream &operator>>(istream &,cls &);

};

ostream &operator<<(ostream &out,const cls obj) { out << obj.c<

return out;

} istream &operator>>(istream &in,cls &obj) { in >> obj.st>>obj.i;

return in;

} main() { cls s(’a’,10),ss(’ ’,0);

out<<"abc"<

cout<

cin >> ss;

return 0;

} Общая форма функции перегрузки оператора ввода-вывода имеет вид:

istream &operator>>(istream &поток,имя_класса &объект) ostream &operator<<(ostream &поток,const имя_класса объект) Как видно, функция принимает в качестве аргумента и возвращает ссылку на поток. В результате доопределенный оператор можно применить последова тельно к нескольким операндам cout <

Это соответствует (cout.operator<<(a)).operator<<(b);

В приведенном примере функция operator не является компонентом клас са cls, так как левым аргументом (в списке параметров) такой функции должен быть this-указатель для объекта, инициирующего перегрузку. Доступ к private данным класса cls осуществляется через friend-функцию operator этого класса.

Рассмотрим использование перегрузки операторов << и >> для определе ния новых манипуляторов. Ранее мы рассмотрели использование стандартных манипуляторов форматирования выводимой информации. Однако можно опре делить и новые манипуляторы без изменения стандартных. В качестве примера рассмотрим переопределение манипулятора с параметрами, задающего для выводимого дробного числа ширину поля и точность.

#include class manip { int n,m;

ostream & (*f)(ostream&,int,int) ;

public:

manip(ostream& (*F)(ostream&,int,int), int N, int M) :

f(F), n(N), m(M) {} friend ostream& operator<<(ostream& s, manip& obj) {return obj.f(s,obj.n,obj.m);

} };

ostream& f_man(ostream & s,int n,int m) { s.width(n);

s.flags(ios::fixed);

s.precision(m);

return s;

} manip wp(int n,int m) { return manip(f_man,n,m);

} void main(void) { cout<< 2.3456 << endl;

cout<

} Компонента-функция put и вывод символов Компонента-функция put() используется для вывода одиночного символа:

char c=’a’;

...

cout.put(c);

Вызовы функции put() могут быть сцеплены:

cout.put(c).put(’b’).put(’\n’);

в этом случае на экран выведется буква а, затем b и далее символ новой строки.

Компоненты-функции get и getline для ввода символов.

Функция get может быть использована в нескольких вариантах.

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

#include main(void) { char c;

cout << in.eof()<< "вводите текст" << endl;

while((c=cin.get())!=EOF) cout.put(c);

cout << endl<

return 0;

} В программе считывается из потока cin очередной символ и выводится с помощью функции put. При считывании признака конца файла завершается цикл while. До и после цикла выводится значение cin.eof(), равное false (выво дится 0) до начала цикла и true (выводится 1) после его окончания.

Второй вариант – когда функция get() используется с одним символь ным аргументом. Функция возвращает false при считывании признака конца файла, иначе – ссылку на объект класса istream, для которого вызывалась функ ция get.

...

while(сin.get(с)) cout.put(c);

...

При третьем варианте функция get() принимает три параметра: сим вольный массив, максимальное число символов и ограничитель ввода (по умол чанию ’\n’). Ввод прекращается, когда считано число символов на один мень шее максимального или считан символ-ограничитель. При этом в вводимую строку добавляется нуль-символ. Символ-ограничитель из входного потока не удаляется, это при повторном вызове функции get приведет к формированию пустой строки.

сhar s[30];

...

сin.get(s,20)) // аналогично cin.get(s,20,’\n’) cout<

...

Функция getline() действует аналогично функции get с тремя параметрами с тем отличием, что символ-ограничитель удаляется из входного потока.

Ниже коротко рассмотрены другие функции-компоненты класса istream.

Состояние потока Потоки iostream или ostream имеют связанное с ними состояние. В классе ios, базовом для классов iostream и ostream, имеется несколько public функций, позволяющих проверять и устанавливать состояние потока:

inline int ios::bad() const { return state & badbit;

} inline int ios::eof() const { return state & eofbit;

} inline int ios::fail() const { return state & (badbit | failbit);

} inline int ios::good() const { return state == 0;

} Состояние потока фиксируется в элементах перечисления, объявленного в классе ios:

public:

enum io_state { goodbit = 0x00, eofbit = 0x01, failbit = 0x02, badbit = 0x04 };

Кроме отмеченных выше функций в классе ios есть еще несколько функ ций, позволяющих прочитать (rdstate) и очистить (clear) состояние потока:

inline int ios::rdstate() const { return state;

} inline void ios::clear(int _i=0){ lock();

state = _i;

unlock();

} Так, если было установлено состояние ошибки, то попытка выполнить ввод/вывод будет игнорироваться до тех пор, пока не будет устранена причина ошибки и биты ошибки не будут сброшены функцией clear().

#include "iostream.h" main() { int i;

int flags;

do{ cin >> i;

flags=cin.rdstate();

// чтение состояния потока cin if(flags | ios::badbit) { cout << "error in stream"<< endl;

cin.clear(0);

// сброс всех состояний потока } } while(flags);

// пока ошибка во входном потоке return 0;

} В приведенном примере функция cin.clear(0) выполняет сброс всех уста новленных бит ошибки. Если требуется сбросить, например, только badbit, то clear(ios::badbit).

...

ifstream in("file");

while(1) { state=in.rdstate();

if (state) { if(state&ios::badbit) cout<<"ошибка открытия файла"<

else if(state&ios::eofbit) cout<<"в файле больше нет данных"<

break;

} else in >> ss;

}...

Необходимо также отметить, что в классе ios выполнена перегрузка опе рации !:

inline int ios::operator!() const { return state&(badbit|failbit);

} то есть операция ! возвращает ненулевое значение в случае установки одного из бит badbit или failbit, иначе нулевое значение, например:

if(!cin) cout << ”ошибка потока cin”<

// проверка состояния else cin>>i;

// входного потока Строковые потоки Особой разновидностью потоков являются строковые потоки, представленные классом strstream:

class strstream : public iostream { public:

strstream();

strstream(char *s, streamsize n, ios_base::openmode=ios_base::in | ios_base::out);

strstreambuf *rdbuf() const;

void freeze(bool frz=true);

char *str();

streamsize pcount() const;

};

Важное свойство класса strstream состоит в том, что в нем автоматически выделяется требуемый объем памяти для хранения строковых данных. Все опе рации со строковыми потоками происходят в памяти в специально выделенном для них буфере strstreambyf. Строковые потоки позволяют облегчить формиро вание данных в памяти. В примере демонстрируется ввод данных в буфер, ко пирование их в компоненту s класса string и их просмотр.

#include "strstrea.h" class string { char s[80];

public:

string(char *S) {for(int i=0;

s[i++]=*S++;

);

} void see(){cout<

} };

void fun(const char *s) { strstream st;

// создание объекта st st << s << ends;

// вывод данных в поток (в буфер) string obj(st.str());

// создание объекта класса string st.rdbuf()->freeze(0);

// освобождение памяти в буфере obj.see();

// просмотр скопированной из буфера строки } main() { fun("1234");

} Вначале создается объект st типа strstream. Далее при выводе переданной в функцию символьной строки в поток добавлен манипулятор ends, который соответствует добавлению ’\0’. Функция str() класса strstream обращается непосредственно к хранимой в буфере строке. Следует отметить, что при обращении к функии str() объект st перестает контролировать эту память и при уничтожении объекта память не освобождается. Для ее освобождения требуется вызвать функцию st.rdbuf()->freeze(0).

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

#include "strstrea.h" void fun(const char *s,int n) { char *buf=new char[n];

// входной буфер strstream st(buf,n,ios::in|ios::out);

// связывание потока st и буфера byf st << s << ends;

// ввод информации в буфер if(st.good()) cout << buf<

// проверка состояния потока else cerr<<"error"<

// вывод сообщения об ошибке } main() { fun("123456789",5);

fun("123456789",15);

} Организация работы с файлами В языке С++ для организации работы с файлами используются классы потоков ifstream (ввод), ofstream (вывод) и fstream (ввод и вывод) (рис. 7).

Перечисленные классы являются производными от istream, ostream и iostream соответственно. Операции ввода-вывода выполняются так же, как и для других потоков, то есть компоненты-функции, операции и манипуляторы могут быть применены и к потокам файлов. Различие состоит в том, как создаются объекты и как они привязываются к требуемым файлам.

ios istream ostream ifstream ofstream iostream fstream Рис. 7. Часть иерархии классов потоков ввода-вывода В С++ файл открывается путем стыковки его с соответствующим потоком. Рассмотрим организацию связывания потока с некоторым файлом.

Для этого используются конструкторы классов ifstream и ofsream:

ofstream(const char* Name, int nMode= ios::out, int nPot= filebuf::openprot);

ifstream(const char* Name, int nMode= ios::in, int nPot= filebuf::openprot);

Первый аргумент определяет имя файла (единственный обязательный параметр).

Второй аргумент задает режим для открытия файла и представляет битовое ИЛИ величин:

ios::app при записи данные добавляются в конец файла, даже если текущая позиция была перед этим изменена функцией ostream::seekp;

ios::ate указатель перемещается в конец файла. Данные записываются в текущую позицию (произвольное место) файла;

ios::in поток создается для ввода: если файл уже существует, то он сохраняется;

ios::out поток создается для вывода (по умолчанию для всех ofstream объектов);

ios::trunc если файл уже существует, его содержимое уничтожается (длина равна нулю). Этот режим действует по умолчанию, если ios::out установлен, а ios::ate, ios::app или ios:in не установлены;

ios::nocreate если файл не существует, функциональные сбои;

ios::noreplace если файл уже существует, функциональные сбои;

ios::binary ввод-вывод будет выполняться в двоичном виде (по умолчанию текстовой режим).

Третий аргумент – данное класса filebuf, используется для установки атрибутов доступа к открываемому файлу.

Возможные значения nProt:

filebuf::sh_compat овместно используют режим;

filebuf::sh_none режим Exclusive: никакое совместное использование;

filebuf::sh_read совместно использующее чтение;

filebuf::sh_write совместно использующее запись.

Для комбинации атрибутов filebuf::sh_read and filebuf::sh_write используется операция логическое ИЛИ ( || ).

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

void open(const char* name, int mode, int prot=fileout::openprot);

Только после того как поток создан и соединен с некоторым файлом (используя либо конструктор с параметрами, либо функцию open), можно выполнять ввод информации в файл или вывод из файла.

#include "iostream.h" #include "fstream.h" #include "string.h" class string { char *st;

int size;

public :

string(char *ST,int SIZE) : size(SIZE) { st=new char[size];

strcpy(st,ST);

} ~string() {delete [] st;

} string(const string &s) // копирующий конструктор необходим, так как { st=new char[s.size];

// при перегрузке << в функцию operator переда- strcpy(st,s.st);

// ется объект, содержащий указатель на строку, а } // в конце вызовется деструктор для объекта obj friend ostream &operator<<(ostream &,const string);

friend istream &operator>>(istream &,string &);

};

ostream &operator<<(ostream &out,const string obj) { out << obj.st << endl;

return out;

} istream &operator>>(istream &in,string &obj) { in >> obj.st;

return in;

} main() { string s("asgg",10),ss("aaa",10);

int state;

ofstream out("file");

if (!out) { cout<<"ошибка открытия файла"<

return 1;

// или exit(1) } out<<"123"<

out<

// запись в файл ifstream in("file");

while(in >> ss) // чтение из файла {cout<

} in.close();

out.close();

return 0;

} В приведенном примере в классе содержится копирующий конструктор, так как в функцию operator передается объект obj, компонентой которого явля ется строка. В инструкции cout <

В операторе if (!out) вызывается (как и ранее для потоков) функция ios::operator! для определения, успешно ли открылся файл.

Условие в заголовке оператора while автоматически вызывает функцию класса ios перегрузки операции void *:

operator void *() const { if(state&(badbit|failbit) ) return 0;

return (void *)this;

} то есть выполняется проверка;

если для потока устанавливается failbit или badbit, то возвращается 0.

Организация файла последовательного доступа В С++ файлу не предписывается никакая структура. Для последователь ного поиска данных в файле программа обычно начинает считывать данные с начала файла до тех пор, пока не будут считаны требуемые данные. При поиске новых данных этот процесс вновь повторяется.

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

Коля 12 Александр то при модификации имени Коля на имя Николай может получиться следую щее:

НиколайАлександр Аналогично в последовательности целых чисел 12 –1 132 32554 7 для хранения каждого из них отводится sizeof(int) байт. А при форматированном выводе их в файл они занимают различное число байт. Следовательно, такая модель ввода-вывода неприменима для модификации информации на месте.

Эта проблема может быть решена перезаписью (с одновременной модификаци ей) в новый файл информации из старого. Это сопряжено с проблемой обработ ки всей информации при модификации только одной записи.

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

#include "fstream.h" #include "stdlib.h" #include "math.h" void error(char *s1,char *s2="") // вывод сообщения об ошибке { cerr<

// при открытии потока для файла exit(1);

} main(int argc,char **argv) { char *buf=new char[20];

int i;

ifstream f1;

// входной поток ofstream f2,f3;

// выходные потоки f1.open(argv[1],ios::in);

// открытие исходного файла if(!f1) // проверка состояния потока error("ошибка открытия файла",argv[1]);

f2.open(argv[2],ios::out);

// открытие 1 выходного файла if(!f2) error("ошибка открытия файла",argv[1]);

f3.open(argv[3],ios::out);

// открытие 2 выходного файла if(!f3) error("ошибка открытия файла",argv[1]);

f1.seekg(0);

// установить текущий указатель в начало потока while(f1.getline(buf,20,' ')) // считывание в буфер до 20 символов { if(int n=f1.gcount()) // число реально считанных символов buf[n-1]='\0';

// проверка на только цифровую строку for(i=0;

*(buf+i)&&(*(buf+i)>='0' && *(buf+i)<='9');

i++);

if(!*(buf+i)) f2 <<::atoi(buf)<<' ';

// преобразование в число и запись // в файл f else f3<

// просто выгрузка буфера в файл f } delete [] buf;

f1.close();

// закрытие файлов f2.close();

f3.close();

} В программе для ввода имен файлов использована командная строка, первый параметр – имя файла источника (входного), а два других – имена фай лов приемников (выходных). Для работы с файлами использованы функции – open, close, seekg, getline и gcount. Более подробное описание функций приве дено ниже.

Ниже приведена программа, выполняющая ввод символов в файл с их од новременным упорядочиванием (при вводе) по алфавиту. Использование функ ций seekg, tellg позволяет позиционировать текущую позицию в файле, то есть осуществлять прямой доступ в файл. Обмен информацией с файлом осуществ ляется посредством функций get и put.

#include "fstream.h" #include "stdlib.h" void error(char *s1,char *s2="") { cerr<

exit(1);

} main() { char c,cc;

int n;

fstream f;

// выходной поток streampos p,pp;

f.open("aaaa",ios::in|ios::out);

// открытие выходного файла if(!f) error("ошибка открытия файла","aaaa");

f.seekp(0);

// установить текущий указатель в начало потока while(1) { cin>>c;

if (c=='q' || f.bad()) break;

f.seekg(0,ios::beg);

while(1) { if(((cc=f.get())>=c) || (f.eof())) { if(f.eof()) { f.clear(0);

p=f.tellg();

} else { p=f.tellg()-1;

f.seekg(-1,ios::end);

pp=f.tellg();

while(p<=pp) { cc=f.get();

f.put(cc);

f.seekg(--pp);

} } f.seekg(p);

f.put(c);

break;

} } } f.close();

return 1;

} Каждому объекту класса istream соответствует указатель get (указывающий на очередной вводимый из потока байт) и указатель put (соответственно на по зицию для вывода байта в поток). Классы istream и ostream содержат по 2 пере груженные компоненты-функции для перемещения указателя в требуемую по зицию в потоке (связанном с ним файле). Такими функциями являются seekg (переместить указатель для извлечения из потока) и seekp (переместить указа тель для помещения в поток).

istream& seekg( streampos pos );

istream& seekg( streamoff off, ios::seek_dir dir );

Сказанное выше справедливо и для функций seekp. Первая функция перемеща ет указатель в позицию рos относительно начала потока. Вторая перемещает соответствующий указатель на off (целое число) байт в трех возможных на правлениях: ios::beg (от начала потока), ios::cur (от текущей позиции) и ios::end (от конца потока). Кроме рассмотренных функций в этих классах имеются еще функции tellg и tellp, возвращающие текущее положение указателей get и put соответственно streampos tellg();

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

Наиболее удобными для организации произвольного доступа при вводе выводе информации являются следующие компоненты-функции:

istream& istream::read(E *s, streamsize n);

ostream& ostream::write(E *s, streamsize n);

при этом, так как функция write (read) ожидает первый аргумент типа const сhar * (char *), то для требуемого приведения типов используется оператор явного преобразования типов:

istream& istream::read(reinterpret_cast(&s), streamsize n);

ostream& ostream::write(reinterpret_cast(&s), streamsize n);

Ниже приведен текст программы организации работы с файлом произ вольного доступа на примере удаления и добавления в файл информации о бан ковских реквизитах клиента (структура inf).

#include #include #include using namespace std;

struct inf { char cl[10];

// клиент int pk;

// пин-код double sm;

// сумма на счете } cldata;

class File { char filename[80];

// имя файла fstream *fstr;

// указатель на поток int maxpos;

// число записей в файле public:

File(char *filename);

~File();

int Open();

const char* GetName();

int Read(inf &);

void Remote();

void Add(inf);

int Del(int pos);

friend ostream& operator << (ostream &out, File &obj) { inf p;

out << "File " << obj.GetName() << endl;

obj.Remote();

while(obj.Read(p)) out<<"\nКлиент -> "<

return out;

} };

File::File(char *_filename) // конструктор { strncpy(filename,_filename,80);

fstr = new fstream();

} File::~File() // деструктор { fstr->close();

} int File::Open() // функция открывает файл для ввода-вывода бинарный { fstr->open(filename, ios::in | ios::out | ios::binary);

if (!fstr->is_open()) return -1;

return 0;

} int File::Read(inf &p) // функция чтения из потока fstr в объект p { if(!fstr->eof() && // если не конец файла fstr->read(reinterpret_cast(&p),sizeof(inf))) return 1;

// fstr->clear();

return 0;

} void File::Remote() // сдвиг указателей get и put в начало потока { fstr->seekg(0,ios_base::beg);

// сдвиг указателя на get на начало fstr->seekp(0,ios_base::beg);

// сдвиг указателя на put на начало fstr->clear();

// чистка состояния потока } const char* File::GetName() // функция возвращает имя файла { return this->filename;

} void File::Add(inf cldata) { fstr->seekp(0,ios_base::end);

fstr->write(reinterpret_cast(&cldata),sizeof(inf));

fstr->flush();

} int File::Del(int pos) // функция удаления из потока записи с номером pos { Remote();

fstr->seekp(0,ios::end);

// для вычисления maxpos maxpos = fstr->tellp();

// позиция указателя put maxpos/=sizeof(inf);

if(maxpos

fstr->seekg(pos*sizeof(inf),ios::beg);

// сдвиг на позицию, // следующую за pos while(posread(reinterpret_cast(&cldata),sizeof(inf));

fstr->seekp(-2*sizeof(inf), ios::cur);

fstr->write(reinterpret_cast(&cldata),sizeof(inf));

fstr->seekg(sizeof(inf),ios::cur);

pos++;

} strcpy(cldata.cl,"");

// для занесения пустой записи в cldata.pk=0;

// конец файла cldata.sm=0;

fstr->seekp(-sizeof(inf), ios::end);

fstr->write(reinterpret_cast(&cldata),sizeof(inf));

fstr->flush();

// выгрузка выходного потока в файл } int main(void) { int n;

File myfile("file");

if(myfile.Open() == -1) { cout << "Can't open the file\n";

return -1;

} cin>>cldata.cl>>cldata.pk>>cldata.sm;

myfile.Add(cldata);

cout << myfile << endl;

// просмотр файла cout << "Введите номер клиента для удаления ";

cin>>n;

if(myfile.Del(n) == -1) cout << "Клиент с номеном "<

cout << myfile << endl;

// просмотр файла } Основные функции классов ios, istream, ostream Из диаграммы классов ввода-вывода следует, что классы ios, istream, ostream являются базовыми для большинства классов. Класс ios является типом синонимом для шаблона класса basic_ios.

template > class basic_ios : public ios_base {public:

iostate rdstate() const;

// возвращает текущее состояние потока void clear(iostate state = goodbit);

// устанавливает состояние потока в // заданное значение. Состояние потока // можно изменить: cin.clear(ios::eofbit) void setstate(iostate state);

bool good() const;

// true-значение при отсутствии ошибки bool eof() const;

// true при достижении конца файла, т.е. при // попытке выполнить в/в за пределами файла bool fail() const;

// true при ошибке в текущей операции bool bad() const;

// true при ошибке basic_ostream *tie() const;

basic_ostream *tie(basic_ostream *str);

basic_streambuf *rdbuf() const;

// возвращает указатель на буфер // ввода-вывода basic_streambuf *rdbuf(basic_streambuf *sb);

basic_ios& copyfmt(const basic_ios& rhs);

locale imbue(const locale& loc);

E widen(char ch);

char narrow(E ch, char dflt);

protected:

basic_ios();

void init(basic_streambuf* sb);

};

Далее приводятся прототипы некоторых функций классов istream и ostream.

template > class basic_istream : virtual public basic_ios {public:

bool ipfx(bool noskip = false);

void isfx();

streamsize gcount() const;

int_type get();

basic_istream& get(E& c);

basic_istream& get(E *s, streamsize n);

basic_istream& get(E *s, streamsize n, E delim);

basic_istream& get(basic_streambuf *sb);

basic_istream& get(basic_streambuf *sb, E delim);

basic_istream& getline(E *s, streamsize n)E basic_istream& getline(E *s, streamsize n, E delim);

basic_istream& ignore(streamsize n = 1, // пропускает n символов или int_type delim = T::eof());

// завершается при считывании // заданного ограничителя по // умолчанию – EOF int_type peek();

// читает символ из потока, не удаляя его из потока basic_istream& read(E *s, streamsize n);

// неформатированный ввод streamsize readsome(E *s, streamsize n);

basic_istream& putback(E c);

// возвращает обратно в поток предыдущий // символ, полученный из потока ф-цией get basic_istream& unget();

pos_type tellg();

basic_istream& seekg(pos_type pos);

basic_istream& seekg(off_type off, ios_base::seek_dir way);

int sync();

};

template > class basic_ostream : virtual public basic_ios {public:

bool opfx();

void osfx();

basic_ostream& put(E c);

basic_ostream& write(E *s, streamsize n);

// неформатированный вывод basic_ostream& flush();

pos_type tellp();

basic_ostream& seekp(pos_type pos);

basic_ostream& seekp(off_type off, ios_base::seek_dir way);

};

Исключения в С++ Исключения – возникновение непредвиденных ошибочных условий, на пример, деление на ноль, невозможность выделения памяти при создании ново го объекта и т.д. Обычно эти условия завершают выполнение программы с сис темной ошибкой. С++ позволяет восстанавливать программу из этих условий и продолжать ее выполнение. В то же время исключение – это более общее, чем ошибка, понятие и может возникать и тогда, когда в программе нет ошибок.

Механизм обработки исключительных ситуаций на сегодняшний день яв ляется неотъемлемой частью языка С++. Этот механизм предоставляет про граммисту средство реагирования на нештатные события и позволяет преодо леть ряд принципиальных недостатков следующих традиционных методов об работки ошибок:

– возврат функцией кода ошибки;

– возврат значений ошибки через аргументы функций;

– использование глобальных переменных ошибки;

– использование оператора безусловного перехода goto или функций setjmp/longjmp;

– использование макроса assert.

Возврат функцией кода ошибки является самым обычным и широко применяемым методом. Однако этот метод имеет существенные недостатки.

Во-первых, нужно помнить численные значения кодов ошибок. Эту проблему можно обойти, используя перечисляемые типы. Но в некоторых случаях функ ция может возвращать широкий диапазон допустимых (неошибочных) значе ний, и тогда сложно найти диапазон для возвращаемых кодов ошибки. Это и является вторым недостатком. И, в-третьих, при использовании такого меха низма сигнализации об ошибках вся ответственность по их обработке ложится на программиста и могут возникнуть ситуации, когда серьезные ошибки будут оставлены без внимания.

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

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

И, наконец, макрос assert является скорее средством отладки, чем средст вом обработки нештатных событий, возникающих в процессе использования программы.

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

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

Рассмотрим пример обработки исключительных ситуаций. Функция div() возвращает частное от деления чисел, принимаемых в качестве аргументов. Ес ли делитель равен нулю, то генерируется исключительная ситуация.

#include double div(double dividend, double divisor) { if(divisor==0) throw 1;

return dividend/divisor;

} void main() { double result;

try { result=div(77.,0.);

cout<<"Answer is "<

} catch(int){ cout<<"Division by zero"<

} } Результат выполнения программы:

Division by zero В данном примере необходимо выделить три ключевых элемента. Во первых, вызов функции div() заключен внутрь блока, который начинается с ключевого слова try. Этот блок указывает, что внутри него могут происходить исключительные ситуации. По этой причине код, заключенный внутри блока try, иногда называют охранным.

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

Еще одним элементом процесса обработки исключительных ситуаций является оператор throw (в данном случае он находится внутри функции div()).

Оператор throw сигнализирует об исключительном событии и генерирует объ ект исключительной ситуации, который перехватывается обработчиком catch.

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

Если в инструкции if(divisor==0) throw 1 значение 1 заменить на 1., то при выполнении будет выдана ошибка об отсутствии соответствующего обра ботчика catch (так как возбуждается исключительная ситуация типа double).

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

Сказанное рассмотрим на примере функции add() класса add_class, вы полняющей сложение компонентов-данных объектов add_class и возвращаю щей суммарный объект. В случае, если сумма превышает максимальное значе ние для типа unsigned short, генерируется исключительная ситуация.

#include #include class add_class { private:

unsigned short num;

public:

add_class(unsigned short a) { num=a;

cout<<"Constructor "<

} ~add_class() { cout<<"Destructor of add_class "<

} void show_num() { cout<<" "<

} void input_num(unsigned short a) { num=a;

} unsigned short output_num(){return num;

} };

add_class add(add_class a,add_class b) { add_class sum(0);

unsigned long s=(unsigned long)a.output_num()+ (unsigned long)b.output_num();

if(s>USHRT_MAX) throw (int)1;

sum.input_num((unsigned short) s);

return sum;

} void main() { add_class a(USHRT_MAX),b(1),s(0);

try{ s=add(a,b);

cout<<"Result";

s.show_num();

cout<

} catch(int){ cout<<"Overflow error"<

} } Результат выполнения программы:

Constructor Constructor Constructor Constructor Destructor of add_class Destructor of add_class Destructor of add_class Overflow error Destructor of add_class Destructor of add_class Destructor of add_class Сначала вызываются конструкторы объектов a, b и s, далее происходит передача параметров по значению в функцию (в этом случае происходит вызов конструктора копий, созданного по умолчанию, именно поэтому вызовов дест руктора больше, чем конструктора), затем, используя конструктор, создается объект sum. После этого генерируется исключение и срабатывает механизм раз вертывания стека, то есть вызываются деструкторы локальных объектов sum, a и b. И, наконец, вызываются деструкторы s, b и a.

Рассмотрим более подробно элементы try, catch и throw механизма обра ботки исключений.

Блок try. Синтаксис блока:

try{ охранный код } список обработчиков Необходимо помнить, что после ключевого слова try всегда должен сле довать составной оператор, т.е. после try всегда следует {…}. Блоки try не име ют однострочной формы, как, например, операторы if, while, for.

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

int i;

try{ throw исключение;

} i=0;

// 'try' block starting on line ' номер ' has no catch handlers catch(тип аргумент){ блок обработки исключения } В блоке try можно размещать любой код, вызовы локальных функций, функции-компоненты объектов, и любой код любой степени вложенности мо жет генерировать исключительные ситуации. Блоки try сами могут быть вло женными.

Обработчики исключительных ситуаций catch. Обработчики исклю чительных ситуаций являются важнейшей частью всего механизма обработки исключений, так как именно они определяют поведение программы после гене рации и перехвата исключительной ситуации. Синтаксис блока catch имеет сле дующий вид:

catch(тип 1 <аргумент>) { тело обработчика } catch(тип 2 <аргумент>)) { тело обработчика }.

.

.

catch(тип N <аргумент>)) { тело обработчика } Таким образом, так же как и в случае блока try, после ключевого слова catch должен следовать составной оператор, заключенный в фигурные скобки.

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

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

typedef int type_int;

try{... } catch(type_int error1){...

} catch(int error2){...

} Так, в этом случае type_int и int – это одно и то же.

Однако следующий пример верен.

class cls { public:

int i;

};

try{...

} catch(cls i1){...

} catch(int i2){ } В этом случае cls – это отдельный тип исключительной ситуации. Суще ствует также абсолютный обработчик, который совместим с любым типом ис ключительной ситуации. Для написания такого обработчика надо вместо аргу ментов написать многоточие (эллипсис).

catch (…){ блок обработки исключения } Использование абсолютного обработчика исключительных ситуаций рас смотрим на примере программы, в которой происходит генерация исключи тельной ситуации типа char *, но обработчик такого типа отсутствует. В этом случае управление передается абсолютному обработчику.

#include #include void int_exception(int i) { if(i>100) throw 1;

} void string_exception() { throw "Error";

} void main() { try{ int_exception(99);

string_exception();

} catch(int){ cout<<"Обработчик для типа Int";

getch();

} catch(...){ cout<<"Абсолютный обработчик ";

getch();

} Результат выполнения программы:

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

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

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

– абсолютный обработчик может обработать любую исключительную си туацию;

– исключительная ситуация может быть обработана обработчиком соот ветствующего типа либо обработчиком ссылки на этот тип;

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

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

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

Следствием из правил 3 и 4 является еще одно утверждение: исключи тельная ситуация может быть направлена обработчику, который может прини мать ссылку на объект базового для данной исключительной ситуации класса.

Это значит, что если, например, класс В – производный от класса А, то обра ботчик ссылки на объект класса А может обрабатывать исключительную ситуа цию класса В (или ссылку на объект класса В).

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

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

#include class A{};

class B{};

class C : public A, public B {};

void f(int i) { if(i) throw C();

// возбуждение исключительной ситуации // типа объект С else throw new C;

// возбуждение исключительной ситуации // типа указатель на объект класса С } void main() { int i;

try{ cin>>i;

f(i);

} catch(A) { cout<<"A handler";

} catch(B&) { cout<<"B& handler";

} catch(C) { cout<<"C handler";

} catch(C*) { cout<<"C* handler";

} catch(A*) { cout<<"A* handler";

} catch(void*) { cout<<"void* handler";

} } В данном примере исключительная ситуация класса С может быть на правлена любому из обработчиков A, B& или C, поэтому выбирается обработ чик, стоящий первым в списке. Аналогично для исключительной ситуации, имеющей тип указателя на объект класса С, выбирается первый подходящий обработчик A* или C*. Эта ситуация также может быть обработана обработчи ками void*. Так как к типу void* может быть приведен любой указатель, то об работчик этого типа будет перехватывать любые исключительные ситуации ти па указателя.

Генерация исключительных ситуаций throw. Исключительные ситуа ции передаются обработчикам с помощью ключевого слова throw. Как ранее отмечалось, обеспечивается вызов деструкторов локальных объектов при выхо де из области видимости, то есть развертывание стека. Однако развертывание стека не обеспечивает уничтожение объектов, созданных динамически. Таким образом, перед генерацией исключительной ситуации необходимо явно освобо дить динамически выделенные блоки памяти.

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

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

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

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

Для того чтобы сделать это, нужно использовать throw без аргументов. В этом случае исключительная ситуация будет перенаправлена к следующему подхо дящему обработчику (подходящий обработчик не ищется ниже в текущем спи ске – сразу осуществляется поиск на более высоком уровне). Приводимый ниже пример демонстрирует организацию такой передачи. Программа содержит вложенный блок try и соответствующий блок catch. Сначала происходит пер вичная обработка, затем исключительная ситуация перенаправляется на более высокий уровень для дальнейшей обработки.

#include void func(int i) { try{ if(i) throw "Error";

} catch(char *s) { cout<

throw;

} } void main() { try{ func(1);

} catch(char *s) { cout<

} } Результат выполнения программы:

Error – выполняется первый обработчик Error – выполняется второй обработчик Если ключевое слово trow используется вне блока catch, то автоматически будет вызвана функция terminate(), которая по умолчанию завершает программу.

Исключительная ситуация, генерируемая оператором new Следует отметить, что некоторые компиляторы поддерживают генерацию исключений в случае ошибки выделения памяти посредством оператора new, в частности исключения типа bad_alloc. Оно может быть перехвачено и необхо димым образом обработано. Ниже в программе рассмотрен пример генерации и обработки исключительной ситуаций bad_alloc. Искусственно вызывается ошибка выделения памяти и перехватывается исключительная ситуация.

#include using std::bad_alloc;

#include void main() { double *p;

try{ while(1) p=new double[100];

// генерация ошибки выделения памяти } catch(bad_alloc exept) { // обработчик xalloc cout<<"Возникло исключение"<

} } В случае если компилятором не генерируется исключение bad_alloc, то можно это исключение создать искусственно:

#include using std::bad_alloc;

#include void main() { double *p;

bad_alloc exept;

try{ if(!(p=new double[100000000])) // память не выделена p==NULL throw exept;

// генерация ошибки выделения памяти } catch(bad_alloc exept) { // обработчик bad_alloc cout<<"Возникло исключение "<

} } Результатом работы программы будет сообщение:

Возникло исключение bad_allocation Оператор new появился в языке C++ еще до того, как был введен меха низм обработки исключительных ситуаций, поэтому первоначально в случае ошибки выделения памяти этот оператор просто возвращал NULL. Если требу ется, чтобы new работал именно так, надо вызвать функцию set_new_handler() с параметром 0. Кроме того, с помощью set_new_handler() можно задать функ цию, которая будет вызываться в случае ошибки выделения памяти. Функция set_new_handler (в заголовочном файле new) принимает в качестве аргумента указатель на функцию для функции, которая не принимает никаких аргументов и возвращает void.

#include #include int error_alloc( size_t ) // size_t unsigned integer результат sizeof operator.

{ cout << "ошибка выделения памяти" <

return 0;

} void main( void ) { _set_new_handler( error_alloc );

int *p = new int[10000000000];

} Результатом работы функции является:

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

Генерация исключений в конструкторах Механизм обработки исключительных ситуаций очень удобен для обра ботки ошибок, возникающих в конструкторах. Так как конструктор не возвра щает значения, то соответственно нельзя возвратить некий код ошибки и при ходится искать альтернативу. В этом случае наилучшим решением является генерация и обработка исключительной ситуации. При генерации исключения внутри конструктора процесс создания объекта прекращается. Если к этому моменту были вызваны конструкторы базовых классов, то будет обеспечен и вызов соответствующих деструкторов. Рассмотрим на примере генерацию ис ключительной ситуации внутри конструктора. Пусть имеется класс В, произ водный от класса А и содержащий в качестве компоненты-данного объект клас са local. В конструкторе класса В генерируется исключительная ситуация.

#include class local { public:

local() { cout<<"Constructor of local"<

} ~local() { cout<<"Destructor of local"<

} };

class A { public:

A() { cout<<"Constructor of A"<

} ~A() { cout<<"Destructor of A"<

} };

class B : public A { public:

local ob;

B(int i) { cout<<"Constructor of B"<

if(i ) throw 1;

} ~B() { cout<<"Destructor of B"<

} };

void main() { try { B ob(1);

} catch(int) { cout<<"int exception handler";

} } Результат выполнения программы:

Constructor of A Constructor of local Constructor of B Destructor of local Destructor of A int exception handler В программе при создании объекта производного класса В сначала вызы ваются конструкторы базового класса А, затем класса local, который является компонентом класса В. После этого вызывается конструктор класса В, в кото ром генерируется исключительная ситуация. Видно, что при этом для всех ра нее созданных объектов вызваны деструкторы, а для объекта самого класса В деструктор не вызывается, так как конструирование этого объекта не было за вершено.

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

Pages:     | 1 || 3 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.