Динамическая строка» и перегрузка операций

Задача №1. Класс «Динамическая  строка» и перегрузка операций

 

Цель   работы:   Изучить   методику   по   созданию   одномерных   динамических

символьных  массивов  при  помощи  конструкторов  с  захватом  динамической  памяти  и 

деструкторов для их уничтожения, а так же способа работы с строковыми объектами.

Познакомиться с механизмом перегрузки операций.

Исходные данные к задаче №1

Общая     постановка.     Пользовательский    класс     String     должен     содержать

необходимые элементы-данные, которые создаются в динамической области памяти.

Ø Конструктор для создания строк:String (…);

Ø Деструктор:~String(); 

Ø Метод ввода исходной строки: Set();

Ø Метод печати:void print(…);

Ø Код методов – вне пространства определения класса

Ø Программа иллюстрирует прямой и косвенный способы обращения к методам

ИНДИВИДУАЛЬНЫЕ ЗАДАНИЯ 

Ввести  с  клавиатуры  строку   символов  S1.  Признак  окончания  ввода  строки  -

нажатие клавиши "Ввод". Программа должна содержать перегруженную  операцию «=»,

использование которой скопирует S1 в S2 при следующих условиях:

1. без 2 первых и 2 последних  символа;

 

Исходный код (Z1.h):

class String{

private:

    char * str; // Динамический массив

    int L;

    void New( const char *str ); // выделение памяти

    void Del(); // удаление памяти

public:

String();   // конструктор по умолчанию

    String(const char * s);  // Конструктор

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

void Set(void);  // Ввод строки

    void Print (void);  // Печать

String & operator=( const String & str );

};

 

String::String() {

char * s = "\0";

New(s);

}

String::String(const char *s) {

New(s);

}

String::~String() {

Del();

}

 

void String::New(const char *s) {

    int size = strlen(s);

    str = new char[size+1]; // массив для строки символов

    L = size;   // длинна строки

    strcpy(str, s );  // копируем строку

}

void String::Del(){

delete [] str;

}

void String::Set(){

    if(strlen(str) > 0)

Del();

    char tmp[1000];

    cin.getline( tmp, 1000 );

    cin.sync();

    New(tmp);

}

void String::Print (void) {

printf("%s\n", str);

}

String & String::operator = (const String &s){

    Del();

    int k = 0;

    char *t = new char[s.L];

    if(s.L > 5) {

for (int i=2; i<s.L-2; i++){

t[k] = s.str[i];

k++ ;

}

t[k] = '\0';

New(t);

    }

    else

New("\0");

    delete [] t;

    return *this;

};

 

void Zadanie1Run(void) {

String S1, S2;

printf("Введите строку S1. Завершите ввод нажатием ENTER\n");

getchar();

S1.Set();

S2 = S1;

printf("\nПосле присвоения S2 выглядет так: ");

S2.Print();

}

 

Блок схемы

 

Задача №2. Иерархия классов. Механизм виртуальных функций 

 

Цель работы: Изучить одну из базовых концепций ООП – наследование классов в

С++,   заключающуюся   в   построении   цепочек   классов,   связанных   иерархически.

Познакомиться с механизмом виртуальных функций.

Исходные данные к задаче 2

Общая постановка. Программа  должна содержать:

Ø Базовый класс Х, включающий два элемента х1, х2 типа int,

Ø конструктор с параметрами для создания  объектов  в динамической  области

памяти,

Ø деструктор,

Ø виртуальные   методы   просмотра   текущего   состояния   и   переустановки

объектов базового класса в новое состояние.

Ø Производный класс У, включающий один элемент у типа int ,

Ø конструктор   с   параметрами   и    списком   инициализаторов,   передающий

данные конструктору базового класса,

Ø переопределенные  методы  просмотра текущего  состояния объектов  и их

переустановки в новое  состояние.

 

ИНДИВИДУАЛЬНЫЕ ЗАДАНИЯ 

Создать в производном  классе метод Run, определяющий:

1.  Сумму компонент классов

 

Исходный код (Z2.h):

class X {

protected:

int *x1, *x2;

public:

X();

X(int, int);

~X();

virtual void Show(void) {};

virtual void Set(void) {};

};

X::X() {

x1 = new int(1);

x2 = new int;

*x2 = 2;

}

X::X(int z1, int z2){

x1 = new int(z1);

x2 = new int;

*x2 = z2;

}

X::~X() {

delete x1;

delete x2;

};

class Y : public X {

private:

int *y;

public:

Y();

Y(int, int, int);

~Y();

long Run();

void Show(void);

void Set(void);

};

Y::Y() : X() {

y = new int(3);

}

Y::Y(int z1, int z2, int z3) : X(z1, z2) {

y = new int(z3);

}

Y::~Y() {

delete y;

};

void Y::Show(void) {

printf("Текущее состояние: %d %d %d\n", *x1, *x2, *y);

}

void Y::Set(void){

printf("Установите новое состояние (x1, x2, y):\n");

scanf("%d%d%d", x1, x2, y);

}

long Y::Run() {

return *x1 + *x2 + *y;

};

 

 

void Zadanie2Run(void) {

Y *y1;

y1 = new Y;

y1->Show();

y1->Set();

printf("Сумма элементов: %d\n", y1->Run());

}

 

Блок схемы

 

 

Задача №3. Шаблоны классов 

 

Цель работы: Изучить приемы создания и использования шаблонов классов.

Исходные данные к задаче 3

Общая постановка. Дано: число  N и последовательность a1, a2, … aN

Создать  шаблон  класса,  порождающего  динамические  одномерные  массивы  с

элементами различных  типов (вещественные, целочисленные, символьные и т.д.). Тип

данных и результат  являются параметрами по отношению  к классу. программа должна

иметь    методы    инициализации,    конструктор,    деструктор,    просмотра    значений

созданного  массива,  а  также  для  решения  задачи  формирования  нового  массива  по

следующим алгоритмам:

Вариант 1. a1, (a1+a2), … ,(a1+a2+…+aN)

 

Исходный код (Z3.h):

template <class TP> 

class SEQ {

protected:

int N;

TP *ARR;

public:

SEQ(int n);  //констр

~SEQ() { //дестр

delete [] ARR;

}

int GetSize(void) { return N;}

void Show(void) {

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

cout << ARR[i] << "\t";

cout << endl;

}

TP * Gen(void) {

TP *X = new TP[N];

TP sum = 0;

for(int i=0; i<N; i++) {

sum += ARR[i];

X[i] = sum;

}

return X;

}

};

template <class TP>

SEQ<TP>::SEQ(int n) {

N = n;

ARR = new TP[N];

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

ARR[i] = i;

}

 

 

void Zadanie3Run(void) {

SEQ < int >  s1(7);

s1.Show();

 

SEQ < float >  s2(5);

s2.Show();

 

float * a1;

a1 = s2.Gen();

printf("Новый массив:\n");

for(int i=0; i<s2.GetSize(); i++)

cout << a1[i] << "\t" ;

cout << endl;

}

 

 

Блок схемы

 

 

 

 

Задача №4. Обработка исключительных ситуаций

 

Цель    работы: освоить   использование    функций   обработки   исключительных

ситуаций, их формат и особенности.

Исходные данные к задаче 4

Общая   постановка.  Даны  два  выражения  Z1  и  Z1.  Написать  функции  для

вычисления   этих   выражений   с   организацией   обнаружения   нештатной    ситуации

(деление на ноль) и ее  обработки. Передача аргументов  в функции – по ссылкам. 

В случае успеха значения Z1 и Z1 будут приблизительно одинаковыми.

 

ИНДИВИДУАЛЬНЫЕ ЗАДАНИЯ

 

Исходный код (Z4.h):

 

float Z1(float &b) {

float x, y;

x = b*b - 4;

if(x < 0) // подкоренное выражение

throw x;

y = 2*b + 2*sqrt(x);

if(y < 0) // подкоренное выражение

throw y;

x = sqrt(x) + b + 2;

if(x == 0) // делитель

throw;

return sqrt(y) / x;

}

 

float Z2(float &b) {

float x;

x = b + 2;

if(x < 0) // подкоренное выражение

throw x;

x = sqrt(x);

if(x == 0) // делитель

throw;

return 1 / x;

}

 

 

void Zadanie4Run(void) {

float b;

printf("Введите 'b': ");

scanf("%f", &b);

try {

printf("Z1: %.5f\n", Z1(b));

printf("Z2: %.5f\n", Z2(b));

}

catch(float z) {

printf("Отрицательное подкоренное выражение (%.5f)\n", z);

}

catch(...) {

printf("Деление на ноль!\n");

}

}

 

 

 

 

Блок схемы

 

 

 

Приложение 1

Код основного модуля программы (VAR01.cpp):

 

#include "stdafx.h"

#include <windows.h>

#include <iostream>

#include <cstring>

 

using namespace std;

 

#include "Z1.h"

#include "Z2.h"

#include "Z3.h"

#include "Z4.h"

 

//основная программа

int main() {

setlocale(0, "rus");

int zid;

do {

system ("cls");

cout << "Выберите номер задания (1..4)"<< endl;

cout << "Для закрытия программы нажмите 5"<< endl;

cin >> zid;

if (!cin) {

cout <<"Введите число!"<< endl;

cin.clear();

fflush(stdin);

        }

system ("cls");

switch (zid) {

case 1:

Zadanie1Run();

break;

case 2:

Zadanie2Run();

break;

case 3:

Zadanie3Run();

break;

case 4:

Zadanie4Run();

break;

}

if(zid != 5)

system ("pause");

}

while (zid != 5);

return 0;

}

 

Приложение 2

Блок-схема основного модуля программы

 

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

Меню для выбора задания:

Задание 1:

Задание 2:

Задание 3:

Задание 4: