 |
Приложение 3. Классы. Перегрузка конструкторов и функций класса. Дружественные функции
|
|
|
|
// Пример создания класса для хранения в одном и том же участке памяти разнотипных данных
// Класс использует перегрузку конструкторов и функций членов,
// а также дружественную функцию
#include "stdafx.h"
#include <iostream>
using namespace std;
const int SLen = 11;
const char Err[] = "\n*** Нет значения ***\n";
class t_Variant
{
char TypeVal; // Тип значения (0 - нет значения; 1 - целое; 2 - вещественное; 3 - строка)
union { // Анонимное объединение для хранения значений разных типов
int IVal;
double DVal;
char SVal [SLen];
};
public:
// Перегруженные конструкторы
t_Variant() { TypeVal = 0; }; // Нет значения
t_Variant(int V) { Set(V); }; // Инициализация целым
t_Variant(double V) { Set(V); }; // Инициализация вещественным
t_Variant(char V[]) { Set(V); }; // Инициализация строкой
// Перегруженные функции члены
void Set(int V) // Присвоение целого значения
{ TypeVal = 1; IVal = V; }
void Set(double V) // Присвоение вещественного значения
{ TypeVal = 2; DVal = V; }
void Set(char V[]) // Присвоение строки
{ TypeVal = 3; strncpy_s(SVal, SLen, V, SLen - 1); }
// Остальные функции члены
int ToInt() // Получение целого значения
{ if (TypeVal == 1) return IVal; else {cout << Err; return 0;} }
double ToDouble() // Получение вещественного значения
{ if (TypeVal == 1 || TypeVal == 2) return DVal; else {cout << Err; return 0;} }
char * ToString() // Получение строки
{ if (TypeVal == 3) return SVal; else {cout << Err; return "";} }
friend char * ConvToStr(t_Variant V, char * Dest); // Дружественная функция
};
char * ConvToStr(t_Variant V, char * Dest) // Дружественная функция
{
switch (V.TypeVal)
{
case 0: strcpy_s(Dest, 100, Err);
break;
case 1: _itoa_s(V.IVal, Dest, 15, 10);
break;
case 2: _gcvt_s(Dest, 20, V.DVal, 10);
break;
case 3: strcpy_s(Dest, 100, V.SVal);
break;
}
return Dest;
}
|
|
|
int _tmain(int argc, _TCHAR* argv[])
{
setlocale(0, "");
t_Variant Var1; // Создаем пустой экземпляр Var1
cout << Var1.ToInt() << endl; // На экране: *** Нет значения *** и 0
Var1.Set(10); // Записываем в экземпляр Var1 целое значение
cout << Var1.ToInt() << endl; // На экране: 10
Var1.Set(3.14); // Записываем в экземпляр Var1 вещественное значение
cout << Var1.ToDouble() << endl; // На экране: 3.14
Var1.Set("This is text"); // Записываем в экземпляр Var1 строку с усечением
cout << Var1.ToString() << endl; // На экране: This is te
t_Variant Var2(6.28); // Создаем экземпляр Var2 с вещественным значением
cout << Var2.ToDouble() << endl; // На экране: 6.28
t_Variant Var3("Text"); // Создаем экземпляр Var3 с текстовым значением
cout << Var3.ToString() << endl; // На экране: Text
// Использование дружественной функции ConvToStr:
Var3.Set("Друг"); // Записываем в Var3 новое значение
char S[100];
cout << ConvToStr(Var3, S) << endl;
cout << S << endl;
system("Pause");
return 0;
}
Приложение 4. Классы. Еще один пример
///////////////////////////////////////////////////////////////////////////////////////////
// Пример реализации класса для работы с одномерными //
// однонаправленными списками. //
// В этой реализации элементы списка индексируются //
// начиная с 0. //
///////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////
// Начало определения класса List //
///////////////////////////////////////////////////////
// Тип данных t_ Inf определяет тип данных информационных частей
// элементов динамического списка. В этом примере в качестве
// информации, хранящейся в элементах списка, используется тип данных double.
// Если необходимо хранить в элементах списка данные другого типа,
// необходимо заменить тип double,
// на нужный тип данных. При этом необходимо скорректировать
// значение определенной ниже константы DefVal.
// Также, возможно, потребуется незначительная коррекция функций-членов
|
|
|
// класса, связанная с операциями с информационными частями элементов списка
typedef double t_ Inf;
// Значение информационной части элементов списка, используемое по умолчанию
const t_ Inf DefVal = 0;
// Структура t_ Item определяет тип данных элемента списка
Struct t_ Item
{
t_ Inf Inf; //Информационная часть - хранит полезную информацию
t_ Item * Adr; // Адресное поле - хранит адрес следующего элемента списка
};
Class List
{
// Закрытые члены-данные класса
t_ Item * Items, // Адрес первого элемента
* End; // Адрес последнего элемента
unsigned Count; // Количество элементов в списке
// Закрытые члены-функции класса
bool ItemExists(unsigned Index); // Проверка наличия элемента по его индексу
t_ Item * Item(unsigned Index); // Получение адреса элемента по его индексу
t_ Item * ExtractItem(unsigned Index); // Выделение элемента из списка по его
// индексу
public:
// Открытые члены-данные класса
// Открытые члены-функции класса
List(unsigned N = 0); // Коструктор класса. N - количество элементов списка
~ List(void); // Деструктор класса
void Init(); // Инициализация пустого списка
void Create(unsigned N = 0); // Создание нового списка из N элементов
void Clear(); // Удаление элементов списка
unsigned ItemCount(); //Возвращает количество элементов в списке
t_ Inf GetItem(unsigned Index); // Получение информационной части элемента
// по его индексу
void PutItem(unsigned Index, t_ Inf Val); // Присвоение значения Val элементу
// с индексом Index
void AddItem(t_ Inf Val = DefVal); // Добавление элемента в конец списка
// (Val - значение информационной части)
void DelItem(unsigned Index); // Удаление из списка элемента с индексом Index
void InsItem(unsigned Index, t_Inf Val = DefVal); // Вставка нового элемента
// в позицию Index
void MoveItem(unsigned OldIndex, unsigned NewIndex); // Перестановка элемента
// с индексом OldIndex
|
|
|
// на позицию NewIndex
};
// ----------------------------------------------
List:: List (unsigned N)
// Конструктор класса List. N - количество элементов в списке.
// Автоматически вызывается при создании объекта
{
// Вначале список пустой:
Init ();
// Создаем в динамической области список из N элементов:
Create (N);
}
// ----------------------------------------------
List:: ~ List ()
// Деструктор класса List. Автоматически вызывается при уничтожении объекта
{
// При уничтожении объекта освобождает динамическую память от списка
Clear ();
}
// ----------------------------------------------
Void List::Init()
// Инициализация пустого списка
{
Count = 0;
Items = 0;
End = 0;
}
// ----------------------------------------------
|
|
|
