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

15 16 17 18 19 20 21

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

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

Содержимое строки после операции a[1]='c': acc

Содержимое строки после операции a[0]='b': bcc

Содержимое строки после операции a[0]=a[2]: ccc

Конструкторы

Пример. Определим класс двумерного вектора. Будем инициализировать его с помощью полярных координат:

#include <iostream.h>

#include <math.h>

#include <conio.h>

class Vector

{

double x, y;

public:

Vector(double rho, double phi);

void show()

{

cout << "Вектор = ("<< x << ", " << y << ")\n";

}

};

Vector::Vector(double rho, double phi = 0)

{

x = rho*cos(phi);

y = rho*sin(phi);

}

void main()

{

clrscr();

Vector v(1), w(-1, 0.5);

v.show(); w.show();

getch();

}

Вектор = (1, 0)

Вектор = (-0.877583, -0.479426)

Пример. Определим класс, объектом которого является стек заданного размера. Продемонстрируем способы вызова конструктора:

class IntStack

{

int *v, size, top;

public:

IntStack(int size);

};

IntStack::IntStack(int size)

{

v = new int[IntStack::size = size];

top = size;

}

void main()

{

IntStack s1(1000);

IntStack s2 = IntStack(1000); // явный

IntStack s3 = 1000; // сокращенный

}

В данном примере будут определены 3 стека, по 1000 элементов в каждом.

Список инициализации

Например:

class Arr // массив чисел с плавающей точкой

{

int n; // максимальное число элементов

double *p; // указатель на массив

public:

Arr(int size, double *a): n(size), p(a) {}

};

Например:

class Pair

{

const int n;

int& adr;

public:

Pair(int n, int a): n(n), adr(a) {}

};

void main()

{

int p = 10;

Pair b(5, p); // в результате b.n = 5, b.adr = 10

}

Пример. Список инициализации и определение двумерного массива с помощью перегрузки операции скобок.

#include <conio.h>

#include <iostream.h>

// Класс - двумерный массив

class twomas

{

// Закрытые элементы

int *p; // Массив

const int m, n; // Размерность массива

public: // Общедоступные элементы

int& operator () (int i, int j) // Перегрузка операции ()

{

return p[(i-1)*n + j - 1];

}

twomas(int m0, int n0):m(m0), n(n0) // Конструктор

{

p = new int [m*n]; // Выделяем память под массив

}

};

void main()

{

int i, j; // Переменные для циклов

twomas t(10, 15); // Создаём двумерный массив t размером 10x15

clrscr(); // Очистка экрана

cout<<"Содержимое двумерного массива:\n";

// Заполнение ячеек массива и вывод его содержимого на экран

for (i=1; i<=10; i++)

{

for (j=1; j<=15; j++)

{

t(i, j) = 100*i+j;

cout<<' '<<t(i,j);

}

cout<<'\n'; // Перевод строки

}

getch(); // Ожидание нажатия клавиши

}

Содержимое двумерного массива:

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

201 202 203 204 205 206 207 208 209 210 211 212 213 214 215

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315

401 402 403 404 405 406 407 408 409 410 411 412 413 414 415

501 502 503 504 505 506 507 508 509 510 511 512 513 514 515

601 602 603 604 605 606 607 608 609 610 611 612 613 614 615

701 702 703 704 705 706 707 708 709 710 711 712 713 714 715

801 802 803 804 805 806 807 808 809 810 811 812 813 814 815

901 902 903 904 905 906 907 908 909 910 911 912 913 914 915

1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015

Деструктор

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

#include <iostream.h>

#include <conio.h>

// Класс - целочисленный стек

class IntStack

{

// Закрытые элементы

int *v; // Массив под стек

int size, top; // Размер стека и положение вершины

public: // Общедоступные элементы

IntStack(int n = 10): size(n), top(n) // Конструктор

{

v = new int[n]; // Выделение памяти под массив (стек)

}

~IntStack() // Деструктор

{

delete []v; // Освобождение памяти

}

int& operator++(int); // Перегрузка постфиксной операции ++

int operator--(); // Перегрузка префиксной операции --

};

int& IntStack::operator++(int) // Перегрузка постфиксной операции ++

{

return v[--top];

}

int IntStack::operator--() // Перегрузка префиксной операции --

{

return v[top++];

}

int main()

{

clrscr(); // Очистка экрана

IntStack *ps = new IntStack(20); // Создание стека ps

// в динамической памяти

IntStack s; // Создание стека s (по умолчанию 10 элементов)

for(int i = 0; i < 10; i++)

s++ = i; // запись чисел 0,1,2,... в стек

cout<<"Содержимое стека:\n";

for(int j = 0; j < 10; j++)

cout << --s << '\n'; // Чтение из стека

(*ps)++ = 100; // Пример занесения в стек ps числа 100

s.~IntStack(); // Явное разрушение стека s

delete ps; // Разрушение стека ps

getch(); // Ожидание нажатия клавиши

return 0; // Выход из программы

}

В результате работы этой программы на экран будут выведены числа 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, каждое с новой строки.

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

#include <stdio.h>

#include <conio.h>

#include <iostream.h>

// Трассировочный класс

class trace

{

const char* msg;

public:

trace(char *m): msg(m) // Конструктор

{

// Вывод сообщения о входе в блок

fprintf(stderr, "Входим в %s\n", msg);