Главная | Обратная связь | Поможем написать вашу работу!
МегаЛекции

Приложение 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;

}

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

Поделиться:





Воспользуйтесь поиском по сайту:



©2015 - 2024 megalektsii.ru Все авторские права принадлежат авторам лекционных материалов. Обратная связь с нами...