Geum.ru

Реализация библиотеки для работы с

Вид материалаДокументы

Содержание


Скриншот №1,2
Скриншот №5,6
Скриншот №9
Скриншот №11
Скриншот №12,13,14
Скриншот №18
Скриншот №20,21,22
Скриншот №24
Заголовочный файл (реализация методов классов)
Подобный материал:
1   2   3   4   5

Скриншот №1,2




Вернуться к таблице тестов

Скриншот №4




Вернуться к таблице тестов

Скриншот №5,6




Вернуться к таблице тестов

Скриншот №8




Вернуться к таблице тестов

Скриншот №9




Вернуться к таблице тестов

Скриншот №10




Вернуться к таблице тестов

Скриншот №11




…



….



Вернуться к таблице тестов

Скриншот №12,13,14




Вернуться к таблице тестов

Скриншот №15,16,17




Вернуться к таблице тестов

Скриншот №18




Вернуться к таблице тестов


Скриншот №19




Вернуться к таблице тестов

Скриншот №20,21,22




Вернуться к таблице тестов

Скриншот №23




Вернуться к таблице тестов

Скриншот №24




Вернуться к таблице тестов


Листинг программы на С++

Заголовочный файл (объявление классов)

// stdafx.h : include file for standard system include files,

// or project specific include files that are used frequently, but

// are changed infrequently

//

#pragma once

#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers

#include

#include

#include

#include


// TODO: reference additional headers your program requires here

class MyArr

{

public:

bool check(char x[80]);

void createArrayStatic();

void createTwoDimenArray();

void createDynArray();

void createDynArrayT();

void MyError(short Err, char x[80]);

};

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

class SearchAndSort

{

public:

virtual void SortMin();

virtual void SortMax();

virtual void printArray();

void searchMax();

void searchMin();

void searchMaxT();

void searchMinT();

void searchMinForSort(short pos);

void searchMaxForSort(short pos);

void searchMinForSortT(short pos);

void searchMaxForSortT(short pos);

void printTwoDimArray();

short GetMax();

short GetNumMax();

short GetMin();

short GetNumMin();

protected:

short max;

short numMax;

short min;

short numMin;

};

class TwoDimenStr : public SearchAndSort

{

public:

void createNewArrayStatic();

void SortMin();

void SortMax();

void printArray();

};

class TwoDimenCol : public SearchAndSort

{

public:

void createNewArrayStatic();

void SortMin();

void SortMax();

void printArray();

};

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

// Одномерный динамический массив

class DynArray

{

short d_AllEl; // число элементов

short * d_hV; // указатель


public:

DynArray ( short ); // конструктор

~DynArray ( void ); // деструктор


short get ( short ); // Получить элемент массива по номеру

short set ( short, short );


void sort_p ( short ); // Сортировка методом вставок.


void sort_b ( short ); // Сортировка методом пузырька

void sort_ch ( short, short ); // Обменная сортировка.

void print ( short );

};


// Двумерный динамический массив

class DynArrayT

{

short d_AllEl; // число элементов

short **d_hW; // указатель


public:

DynArrayT ( short, short ); // конструктор

~DynArrayT ( void ); // деструктор

short get ( short, short ); // Получить элемент массива по номеру

void print ( void );

void rebuild ( void );

};

Заголовочный файл (реализация методов классов)

// for visual

#include “stdafx.h”

#pragma hdrstop

#include

#include

#include

//#include

#include


// for borland

/*

#include

#include

#include

#include

#include

*/


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

using namespace std;

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

char bufRus[256];

/*

// for borland

char* Rus (char text)

{

CharToOem(text, bufRus);

return bufRus;

}

*/


// for visual

char* Rus(char* in)

{

if (CharToOemA (in, bufRus))

return bufRus;

else return 0;

}

//------------------- КОНСТАНТЫ ---------------------------------------------

const short nn = 127,

ss = 127, // кол-во строк

cc = 127, // кол-во столбцов

ll = (ss*cc)/127; // кол-во элементов (строк * столбцов)


short n,s,c,l;

short ArrayStatic[nn];

short TwoDimenArray[ss][cc];

short NewArrayStatic[ll];


DynArray vp ( nn );

DynArray vb ( nn );

DynArray vc ( nn );

DynArrayT wp ( ss, cc);


//======================= ОБЩИЕ МЕТОДЫ ==================================


//------------------- СООБЩЕНИЯ ОБ ОШИБКАХ -------------------------------------

void MyArr::MyError(short Err, char x[10]){

switch (Err){

case 0 : cout << (Rus(“\a\t Введеное вами значение “)); cout<< x; cout << (Rus( “ не является целым числом\n\n”)); break;

case 1 : cout << (Rus(«\a Введеное вами значение выходит за пределы заданного диапазона от 1 до 127\n\n»));break;

case 2 : cout << (Rus(«\a Введеное вами значение выходит за пределы заданного диапазона от -128 до 127\n\n»));break;

case 3 : cout << (Rus(«\a Введеное вами значение выходит за пределы заданного диапазона от 1 до «))<<(127/atoi(x))<<»\n\n»;break;

case 4 : cout << (Rus(«\a\t Данного пункта меню не существует\n\n»));break;

default : break;

}


}

//------------------ ПРОВЕРКА ВВОДИМЫХ ДАННЫХ ----------------------------------


bool MyArr::check(char x[80]){

short j=0,z;

bool d;

if (x[0]==’-‘) { d=false; j++;z=5;}

z=4;

while (x[j]!=’\0’ && j
d = isdigit (x[j]); j++;

if (!d) return d; else d =true;

}

x[j]=’\0’;

return d;

}

//------------- СОЗДАНИЕ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ------------------------

void MyArr::createArrayStatic(){

char x[80] ;

short i=0,a=0;


while (1)

{

cout<<(Rus(«\tВведите количество элементов массива от 1 до 127»))<<»\n»;

cin >> x ;

if (MyArr::check(x) )

{

n=atoi(x) ;

if (n>0 && n<=127) { break; }

else MyArr::MyError(1, x);

}

else MyArr::MyError(0, x);

}

while (i
{

cout<<(Rus(«Введите элемент массива – целое число от -128 до 127\n»));

cin >> x ;

if (MyArr::check(x) )

{

a=atoi(x) ;

if (a>=-128 && a<=127)

{ ArrayStatic[i]=a; i++; }

else MyArr::MyError(2, x);

}

else MyArr::MyError(0, x);

}

}

//--------------- СОЗДАНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА -------------------

void MyArr::createTwoDimenArray(){

char x[80];char y[80];char el[80];

short k=0,a=0,temp=0;

while (1)

{

cout<<(Rus(«\tВведите количество строк массива от 1 до 127»))<<»\n»;

cin >> x ;

if (MyArr::check(x) )

{

n=atoi(x) ;

if (n>0 && n<=127) { break; }

else MyArr::MyError(1, x);

}

else MyArr::MyError(0, x);

}

while (1)

{

cout<<(Rus(«\tВведите количество столбцов массива от 1 до «))<<(127/atoi(x))<<»\n»;

cin >> y ;

if (MyArr::check(y) )

{

n=atoi(y) ;

if (n>0 && n<=(127/atoi(x))) { break; }

else MyArr::MyError(3, x);

}

else MyArr::MyError(0, y);

}

s=atoi(x) ; c=atoi(y);

while (k
{

cout<<(Rus(«Введите элемент массива – целое число от -128 до 127\n»));

cin >> el ;

if (MyArr::check(el) )

{

a=atoi(el) ;

if (a>=-128 && a<=127)

{ ArrayStatic[k]=a; k++; }

else MyArr::MyError(2, x);

}

else MyArr::MyError(0, x);

}

k=0;

for (short i=0; i
for (short j = 0; j < c; j++){

temp = ArrayStatic[k];

TwoDimenArray[i][j] = temp;

k++;

}

}


//------------- СОЗДАНИЕ ОДНОМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА ---------------

void MyArr::createDynArray(){

char x[80] ;

short i=0,a=0;


while (1)

{

cout<<(Rus(«\tВведите количество элементов массива от 1 до 127»))<<»\n»;

cin >> x ;

if (MyArr::check(x) )

{

n=atoi(x) ;

if (n>0 && n<=127) { break; }

}

cout<< (Rus(«\a\t\tВведено ошибочное значение\n\n»));

}

while (i
{

cout<<(Rus(«Введите элемент массива – целое число от -128 до 127\n»));

cin >> x ;

if (MyArr::check(x) )

{

a=atoi(x) ;

if (a>=-128 && a<=127)

{vp.set(i, a); vb.set(i, a); vc.set(i, a); i++;}

else cout<< (Rus(«\a\t\tВведено ошибочное значение\n\n»));

}

else cout<< (Rus(«\a\t\tВведено ошибочное значение\n\n»));

}

}

//---------------- СОЗДАНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ------------------

void MyArr::createDynArrayT(){

char x[80];char y[80];char el[80];

short k=0,a=0,temp=0;

while (1)

{

cout<<(Rus(«\tВведите количество строк массива от 1 до 127»))<<»\n»;

cin >> x ;

if (MyArr::check(x) )

{

n=atoi(x) ;

if (n>0 && n<=127) { break; }

}

cout<< (Rus(«\a\t\tВведено ошибочное значение\n\n»));

}

while (1)

{

cout<<(Rus(«\tВведите количество столбцов массива от 1 до «))<<(127/atoi(x))<<»\n»;

cin >> y ;

if (MyArr::check(y) )

{

n=atoi(y) ;

if (n>0 && n<=(127/atoi(x))) { break; }

}

cout<< (Rus(«\a\t\tВведено ошибочное значение\n\n»));

}

s=atoi(x) ; c=atoi(y);

while (k
{

cout<<(Rus(«Введите элемент массива – целое число от -128 до 127\n»));

cin >> el ;

if (MyArr::check(el) )

{

a=atoi(el) ;

if (a>=-128 && a<=127)

{vp.set(k, a); k++;}

else cout<< (Rus(“\a\t\tВведено ошибочное значение\n\n”));

}

else cout<< (Rus(“\a\t\tВведено ошибочное значение\n\n”));

}

}

//--- ВЫВОД НА ПЕЧАТЬ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void SearchAndSort::printArray(){

for (short i = 0; i
cout << ArrayStatic[i]<<”\t”;

cout <<”\n”;

}

//--- ВЫВОД НА ПЕЧАТЬ ИСХОДНОГО ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void SearchAndSort::printTwoDimArray(){

for (short i = 0; i< s; i++){

for (short j = 0; j < c; j++)

cout << TwoDimenArray[i][j]<<”\t”;

cout <<»\n»;

}

}

//================= ИНДИВИДУАЛЬНЫЕ МЕТОДЫ ======================

//--- ПОИСК ПЕРВОГО МАКСИМАЛЬНОГО ЭЛЕМЕНТА И ЕГО НОМЕРА В ОДНОМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ ---

void SearchAndSort::searchMax(){

max = ArrayStatic[0];

numMax = 1;

for (short i = 0; i
if (ArrayStatic[i] > max) {

max = ArrayStatic[i];

numMax = i + 1;

}

}

//--- ПОИСК ПЕРВОГО МИНИМАЛЬНОГО ЭЛЕМЕНТА И ЕГО НОМЕРА В ОДНОМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ ---

void SearchAndSort::searchMin(){

min = ArrayStatic[0];

numMin = 1;

for (short i = 0; i
if (ArrayStatic[i] < min) {

min = ArrayStatic[i];

numMin = i + 1 ;

}

}

//--- ВЗЯТИЕ ПЕРВОГО МАКСИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

short SearchAndSort::GetMax(){

return max;

}

//--- ВЗЯТИЕ ПЕРВОГО МИНИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

short SearchAndSort::GetMin(){

return min;

}

//--- ВЗЯТИЕ НОМЕРА ПЕРВОГО МАКСИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

short SearchAndSort::GetNumMax(){

return numMax;

}

//--- ВЗЯТИЕ НОМЕРА ПЕРВОГО МИНИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

short SearchAndSort::GetNumMin(){

return numMin;

}

//--- ПОИСК МИНИМАЛЬНОГО ЭЛЕМЕНТА В ОДНОМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ,ПЕРЕДАЧА ЕГО ПОЗИЦИИ В СОРТИРОВКУ ---

void SearchAndSort::searchMinForSort(short pos){

min = ArrayStatic[pos];

numMin = pos;

for (short i = pos; i
if (ArrayStatic[i] < min) {

min = ArrayStatic[i];

numMin = i ;

}

}

//--- СОРТИРОВКА ВСТАВКАМИ ПО ВОЗРАСТАНИЮ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void SearchAndSort::SortMin(){

short temp;

for (short i=0; i
SearchAndSort::searchMinForSort(i);

temp = ArrayStatic[i];

ArrayStatic[i]= SearchAndSort::GetMin();

ArrayStatic[SearchAndSort::GetNumMin()]= temp;

}

}

//--- ПОИСК МАКСИМАЛЬНОГО ЭЛЕМЕНТА В ОДНОМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ,ПЕРЕДАЧА ЕГО ПОЗИЦИИ В СОРТИРОВКУ ---

void SearchAndSort::searchMaxForSort(short pos){

max = ArrayStatic[pos];

numMax = pos;

for (short i = pos; i
if (ArrayStatic[i] > max) {

max = ArrayStatic[i];

numMax = i ;

}

}

//--- СОРТИРОВКА ВСТАВКАМИ ПО УБЫВАНИЮ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void SearchAndSort::SortMax(){

short temp;

for (short i=0; i
SearchAndSort::searchMaxForSort(i);

temp = ArrayStatic[i];

ArrayStatic[i] = SearchAndSort::GetMax();

ArrayStatic[SearchAndSort::GetNumMax()] = temp;

}

}

//--- ПОИСК МИНИМАЛЬНОГО ЭЛЕМЕНТА В ДВУМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ,ПЕРЕДАЧА ЕГО ПОЗИЦИИ В СОРТИРОВКУ ---

void SearchAndSort::searchMinForSortT(short pos){

l=s*c;

min = NewArrayStatic[pos];

numMin = pos;

for (short i = pos; i
if (NewArrayStatic[i] < min) {

min = NewArrayStatic[i];

numMin = i ;

}

}

//--- ПОИСК МАКСИМАЛЬНОГО ЭЛЕМЕНТА В ДВУМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ,ПЕРЕДАЧА ЕГО ПОЗИЦИИ В СОРТИРОВКУ ---

void SearchAndSort::searchMaxForSortT(short pos){

l=s*c;

max = NewArrayStatic[pos];

numMax = pos;

for (short i = pos; i
if (NewArrayStatic[i] > max) {

max = NewArrayStatic[i];

numMax = i ;

}

}

//--- ПОИСК ПЕРВОГО МАКСИМАЛЬНОГО ЭЛЕМЕНТА И ЕГО НОМЕРА В ДВУМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ ---

void SearchAndSort::searchMaxT(){

l=s*c;

max = NewArrayStatic[0];

numMax = 1;

for (short i = 0; i
if (NewArrayStatic[i] > max) {

max = NewArrayStatic[i];

numMax = i + 1;

}

}

//--- ПОИСК ПЕРВОГО МИНИМАЛЬНОГО ЭЛЕМЕНТА И ЕГО НОМЕРА В ДВУМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ ---

void SearchAndSort::searchMinT(){

l=s*c;

min = NewArrayStatic[0];

numMin = 1;

for (short i = 0; i
if (NewArrayStatic[i] < min) {

min = NewArrayStatic[i];

numMin = i + 1 ;

}

}

//------------------------- ДВУМЕРНЫЕ СТАТИЧЕСКИЕ---------------------------------------

//--- СОЗДАНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ВЫПРЯМЛЕННОГО ПО СТРОКАМ ---

void TwoDimenStr::createNewArrayStatic (){

short temp = 0,k = 0;

for (short i = 0; i < s; i++)

for (short j = 0; j < c; j++){

temp = TwoDimenArray [i][j];

NewArrayStatic[k]=temp;

k++;

}

}

//--- СОРТИРОВКА ВСТАВКАМИ ПО СТРОКАМ ПО ВОЗРАСТАНИЮ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void TwoDimenStr::SortMin(){

l=s*c;

short temp;

for (short i=0; i
TwoDimenStr::searchMinForSortT(i);

temp = NewArrayStatic[i];

NewArrayStatic[i] = TwoDimenStr::GetMin();

NewArrayStatic[TwoDimenStr::GetNumMin()]= temp;

}

}

//--- СОРТИРОВКА ВСТАВКАМИ ПО СТРОКАМ ПО УБЫВАНИЮ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void TwoDimenStr::SortMax(){

l=s*c;

short temp;

for (short i=0; i
TwoDimenStr::searchMaxForSortT(i);

temp = NewArrayStatic[i];

NewArrayStatic[i] = TwoDimenStr::GetMax();

NewArrayStatic[TwoDimenStr::GetNumMax()]= temp;

}

}

//--- ВЫВОД НА ПЕЧАТЬ ОТСОРТИРОВАННОГО ПО СТРОКАМ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void TwoDimenStr::printArray (){

short temp,k=0;

for (short i=0; i
for (short j = 0; j < c; j++){

temp = NewArrayStatic[k];

TwoDimenArray[i][j]=temp;

k++;

}

for (short i = 0; i< s; i++){

for (short j = 0; j < c; j++)

cout << TwoDimenArray[i][j]<<”\t”;

cout <<»\n»;

}

}

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

//--- СОЗДАНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ВЫПРЯМЛЕННОГО ПО СТОЛБЦАМ ---

void TwoDimenCol::createNewArrayStatic (){

short temp = 0,k = 0;

for (short j = 0; j < c; j++)

for (short i = 0; i < s; i++){

temp = TwoDimenArray [i][j];

NewArrayStatic[k]=temp;

k++;

}

}

//--- СОРТИРОВКА ВСТАВКАМИ ПО СТОЛБЦАМ ПО ВОЗРАСТАНИЮ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void TwoDimenCol::SortMin(){

l=s*c;

short temp;

for (short i=0; i
TwoDimenCol::searchMinForSortT(i);

temp = NewArrayStatic[i];

NewArrayStatic[i] = TwoDimenCol::GetMin();

NewArrayStatic[TwoDimenCol::GetNumMin()]= temp;

}

}

//--- СОРТИРОВКА ВСТАВКАМИ ПО СТОЛБЦАМ ПО УБЫВАНИЮ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void TwoDimenCol::SortMax(){

l=s*c;

short temp;

for (short i=0; i
TwoDimenCol::searchMaxForSortT(i);

temp = NewArrayStatic[i];

NewArrayStatic[i] = TwoDimenCol::GetMax();

NewArrayStatic[TwoDimenCol::GetNumMax()]= temp;

}

}

//--- ВЫВОД НА ПЕЧАТЬ ОТСОРТИРОВАННОГО ПО СТОЛБЦАМ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

void TwoDimenCol::printArray (){

short temp,k=0;

for (short i=0; i
for (short j = 0; j < s; j++){

temp = NewArrayStatic[k];

TwoDimenArray[j][i]=temp;

k++;

}

for (short i = 0; i< s; i++){

for (short j = 0; j < c; j++)

cout << TwoDimenArray[i][j]<<”\t”;

cout <<”\n”;

}

}


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

DynArray::DynArray ( short in1 )

{

d_hV = new short [in1];

}


DynArray::~DynArray ( void )

{

delete[]d_hV;

}


short DynArray::get ( short in1 )

{

return d_hV[in1];

}


short DynArray::set ( short in1, short in2 )

{

d_hV[in1] = in2;

return 0;

}


void DynArray::sort_p ( short in1 )

{

short i, j, tmp;


for (i = 0; i < in1; i++ )

{

tmp = d_hV[i];

for(j = i-1; j >= 0 && tmp < d_hV[j]; j--)

d_hV[j+1] = d_hV[j];

d_hV[j+1] = tmp;

}

}


void DynArray::sort_b ( short in1 )

{

short i,j,tmp;


for(i = 1; i < in1; i++)

for(j = in1 – 1; j >= i; j--)

if(d_hV[j-1] > d_hV[j])

{

tmp = d_hV[j-1];

d_hV[j-1] = d_hV[j];

d_hV[j] = tmp;

}

}


void DynArray::sort_ch (short in1, short in2)

{

int i = in1, j = in2, tmp, x = d_hV[(in1 + in2) / 2];


do {

while (d_hV[i] < x) ++i;

while (d_hV[j] > x) –j;

if(i <= j) {

if (i < j)

{

tmp = d_hV[j];

d_hV[j] = d_hV[i];

d_hV[i] = tmp;

};

++i;

--j;

}

} while (i <= j);


if (i < in2)

sort_ch(i, in2);

if (in1

< j)

sort_ch(in1,j);


}


void DynArray::print ( short in1 )

{

for (short i = 0; i< in1; i++){

cout << d_hV[i]<<»\t»;

}

cout <<»\n»;

}


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


DynArrayT::DynArrayT ( short in1, short in2 )

{

short i,j;


d_hW = new short*[in1];

for (i = 0; i < in1; i++)

d_hW[i] = new short[in2];

}

DynArrayT::~DynArrayT ( void )

{

short i;


for (i = 0; i < nn; i++)

delete[]d_hW[i];

delete[]d_hW;

}


short DynArrayT::get ( short in1, short in2 )

{

return d_hW[in1][in2];

}


void DynArrayT::rebuild ( void )

{

short temp,k=0;

for (short i=0; i
for (short j = 0; j < s; j++){

temp = vp.get(k);

d_hW[i][j]=temp;

k++;

}

}


void DynArrayT::print ( void )

{

for (short i = 0; i< s; i++){

for (short j = 0; j < c; j++)

cout << d_hW[i][j]<<”\t”;

cout <<»\n»;

}

}


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