 |
Приложение 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;
}
Приложение 2. Классы. Встроенные функции, конструктор и деструктор
// Class_DinArr_2.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:
t_DinArr (unsigned N = 0) { Init(N); } // Конструктор класса
~ t_DinArr () { Free(); } // Деструктор класса
// Открытые члены-функции класса
// ----------------------------------------------
void Init (unsigned N = 0) // Инициализация массива из N элементов
{
if (N)
Arr = (t_Inf *) malloc (sizeof(t_Inf) * N);
else
Arr = 0;
ItemCount = N;
Clear();
}
// ----------------------------------------------
void Clear(); // Очистка массива
// ----------------------------------------------
void Set (unsigned Ind, t_Inf Val) // Запись значения Val в элемент с индексом Ind
{
if (Ind >= ItemCount)
cout << Err << Ind << '!\n';
else
Arr [Ind] = Val;
}
// ----------------------------------------------
t_Inf Get (unsigned Ind) // Возвращает значение элемента с индексом Ind
{
|
|
|
if (Ind >= ItemCount)
{
cout << Err << Ind << "!\n";
return DefVal;
}
else
return Arr [ Ind ];
}
// ----------------------------------------------
void Add (t_Inf Val) // Добавляет в конец массива элемент со значением Val
{
++ ItemCount;
Arr = (t_Inf *) realloc (Arr, sizeof(t_Inf) * ItemCount);
Arr [ ItemCount - 1 ] = Val;
}
// ----------------------------------------------
unsigned Count () { return ItemCount; } // Возвращает количество элементов массива
// ----------------------------------------------
void Free () // Удаление массива из динамической памяти
{
if (Arr)
{
free(Arr);
Arr = 0;
ItemCount = 0;
}
}
};
void t_DinArr:: Clear () // Очистка массива значениями DefVal
{
for (unsigned i = 0; i < ItemCount; ++ i)
Arr [i] = DefVal;
}
/////// Конец описания класса ////////
int main ()
{
setlocale (0, "");
// Вводим с клавиатуры необходимый размер массива:
unsigned N;
cout << "Количество элементов в массиве: ";
cin >> N;
// Создаем экземпляр класса (статическая переменная DA типа t_DinArr) с помощью конструктора:
t_DinArr DA(N);
// Существуют и другие способы использования конструктора, например:
// 1) t_DinArr DA = N;
// 2) t_DinArr DA = t_DinArr(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;
system ("pause");
return 0;
// При завершении программы локальная переменная DA (экземпляр класса) уничтожается,
// при этом автоматически вызывается деструктор класса, который освобождает динамическую память
|
|
|
}
|
|
|
