Приложение 1. Классы. Пример класса с внешней реализацией функций членов (без конструктора и деструктора)

// Class_DinArr_1.cpp: пример класса t_DinArr без встроенных функций и без конструктора и деструктора

//

#include "stdafx.h"

#include <iostream>

#include <conio.h>

using namespace std;

typedef double t_Inf; // Тип данных элементов массива

const t_Inf DefVal = 0; // Значение элемента массива по умолчанию

char Err [] = "\n***В массиве нет элемента с индексом "; // Сообщение об ошибке

/////// Начало описания класса ////////

class t_DinArr {

// Закрытые члены-данные класса

t_Inf *Arr; // Указатель на динамический массив

unsigned ItemCount; // Количество элементов в массиве

public:

// Открытые члены-функции класса

void Init (unsigned N = 0); // Инициализация массива из N элементов

void Clear(); // Очистка массива

void Set (unsigned Ind, t_Inf Val); // Запись значения Val в элемент с индексом Ind

t_Inf Get (unsigned Ind); // Возвращает значение элемента с индексом Ind

void Add ( t_Inf Val ); // Добавляет в конец массива элемент со значением Val

unsigned Count (); // Возвращает количество элементов массива

void Free (); // Удаление массива из динамической памяти

} ;

// ----------------------------------------------

void t_DinArr :: Init (unsigned N) // Инициализация массива из N элементов

{

if (N) // Если N больше 0

// Выделяем память в динамической области для N элементов массива

Arr = (t_Inf *) malloc ( sizeof(t_Inf) * N );

else

// При N = 0 указатель на массив равен 0 – массива нет

Arr = 0;

// Устанавливаем значение количества элементов в массиве

ItemCount = N;

// Очищаем массив значениями DefVal

Clear();

}

// ----------------------------------------------

void t_DinArr :: Clear () // Очистка массива значениями DefVal

{

for (unsigned i = 0; i < ItemCount; ++ i)

Arr [i] = DefVal;

}

// ----------------------------------------------

// Запись значения Val в элемент с индексом Ind

void t_DinArr :: Set(unsigned Ind, t_Inf Val)

{

if (Ind >= ItemCount) // Индекс выходит за границу массива

cout << Err << Ind << '!\n'; // Выводим сообщение об ошибке

else // Индекс правильный

Arr [Ind] = Val; // Элементу массива с индексом Ind присваиваем значение Val

}

// ----------------------------------------------

// Возвращает значение элемента с индексом Ind

t_Inf t_DinArr :: Get(unsigned Ind)

{

if ( Ind >= ItemCount ) // Индекс выходит за границу массива

{

cout << Err << Ind << "!\n"; // Выводим сообщение об ошибке

return DefVal; // Возвращаем из функции значение DefVal

}

else // Индекс правильный

return Arr [ Ind ]; // Возвращаем из функции значение элемента с индексом Ind

}

// ----------------------------------------------

// Добавляет в конец массива элемент со значением Val

void t_DinArr :: Add(t_Inf Val)

{

++ ItemCount; // Количество элементов в массиве увеличиваем на 1

// Увеличиваем размер массива до нового количества элементов

Arr = ( t_Inf * ) realloc ( Arr, sizeof(t_Inf) * ItemCount );

// В новый (последний) элемент массива записываем значение Val

Arr [ ItemCount - 1 ] = Val;

}

// ----------------------------------------------

unsigned t_DinArr :: Count() // Возвращает количество элементов массива

{

return ItemCount;

}

// ----------------------------------------------

void t_DinArr :: Free () // Удаление массива из динамической памяти

{

if (Arr) // Указатель на массив не равен 0 – массив есть

{

free(Arr); // Освобождаем динамическую память

Arr = 0; // Делаем указатель на массив равным 0 – массива нет

ItemCount = 0; // Присваиваем количеству элементов в массиве значение 0

}

}

// ----------------------------------------------

/////// Конец описания класса ////////

int main ( )

{

setlocale ( 0, "" );

// Описываем экземпляр класса (статическая переменная DA типа t_DinArr):

t_DinArr DA;

// Вводим с клавиатуры необходимый размер массива:

unsigned N;

cout << "Количество элементов в массиве: ";

cin >> N;

// Инициализируем экземпляр класса (при этом в динамической области

// памяти будет создан массив на заданное количество элементов

// и этот массив будет «обнулён» значениями DefVal):

DA.Init ( N );

// В цикле заполняем созданный массив некоторыми значениями, например,

// равными индексам элементов массива:

for ( unsigned i = 0; i < DA.Count ( ); ++ i )

DA.Set ( i, i );

// Для контроля выводим на экран значения элементов массива:

for ( unsigned i = 0; i < DA.Count ( ); ++ i )

cout << DA.Get ( i ) << ' '; // на экране видим числа: 0 1 2 … N-1

cout << endl;

// В цикле добавляем в конец массива еще 5 элементов, информационные части

// которых заполняются значениями, от N до N + 4

for ( unsigned i = 0; i < 5; ++ i )

DA.Add ( N + i );

// Снова для контроля выводим на экран значения элементов массива:

for ( unsigned i = 0; i < DA.Count ( ); ++ i )

cout << DA.Get ( i ) << ' '; // на экране видим числа: 0 1 2 … N + 4

cout << endl;

// Заканчиваем работу с массивом (освобождаем динамическую память):

DA.Free ( );

system ( "pause" );

return 0;

}