Forums.Avtograd.Ru: Обсуждаем ООП в языках c / c++ - Forums.Avtograd.Ru

Перейти к содержимому

Страница 1 из 1
  • Вы не можете создать новую тему
  • Вы не можете ответить в тему

Обсуждаем ООП в языках c / c++ Планируем. Пишим. Тестим.

#1 Пользователь офлайн   sawrus

  • Пользователь
  • PipPip
  • Группа: Пользователи
  • Сообщений: 162
  • Регистрация: 07 Ноябрь 07

Иконки сообщения  Отправлено 10 Июль 2008 - 00:29

Как автор темы могу предложить вам оценить работу,
которая была написана в конце 2 курса.
Предлагаю обсуждать в этой теме вопросы, связанные
непостредственно с основами и возможностями ООП для
языков категории c / cpp.
Сам конечно в этом далеко не гуру, но думаю что поговорить
о чём найдётся. :) - цель; узнать как часто в своих проектах
другие программисты используют принципы и само ООП.

=========================================================
язык: cpp
//модуль для работы с матрицами произвольного размера и содержания
- аналог <LIST> из MFC

 с возможностями: 
                 1) создания матрицы любого вида
	 	  2) добавления и изменения любого кол-ва строк и столбцов 	
		  3) печати матрицы и подматрицы заданного размера	
		  4) перехода по матрице и предоставление информации об элементе
		  5) поиска строки, столбца, элемента матрицы
=========================================================
#ifndef LIST_H
#define LIST_H

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

//abstract class Data
class Data{
public:
//============= constructor / destructor  ==============
	Data():iDataNumber(0){ }
	Data(int iNewDataNumber):iDataNumber(iNewDataNumber){ }
	virtual ~Data(){ }
//============= Get / Set for DataNumber  ==============
	int GetDataNumber() const {return iDataNumber;}
	void SetDataNumber(int iNewDataNumber)
	{ iDataNumber = iNewDataNumber;}
//============= virtual Display()for Data ==============
	virtual void Display() const = 0;
//============= virtual for IntData       ==============
	virtual void SetInfo(int,int) const{ }
	virtual int GetInfo() const = 0;
//============= virtual func for DataList ==============
	virtual int GetCount() const = 0;
	virtual Data * GetFirst() const = 0;
	virtual Data * GetData() const = 0;
	virtual Data * Find(int) const = 0;	
	virtual Data * FindAndSet(Data *) const = 0;	
	virtual Data * operator[](int) const = 0;
//============= virtual void for DataList ==============
	virtual void Insert(Data *){ }
	virtual void Iterate(){ }	
	virtual void ShowAll(){ }
	virtual void DisplayList(){ }
	virtual void SetHead(){ }
	virtual void Find(){ }
	virtual bool Remove(int)= 0;
private:
	int iDataNumber;
};

void Data::Display() const
{
	printf("[%d]",iDataNumber);
}


//int class IntData
class IntData: public Data
{
public:
//============= constructor for IntData   ==============
	IntData():iDataInfo(0){ }
	IntData(int iNewDataNumber, int iNewDataInfo);
//============= Display() for IntData     ==============
	void Display() const
	{	Data::Display(); printf("%d;\t",iDataInfo); }
//============= Set/Get Info for IntData  ==============
	void SetInfo(int iNewDataNumber, int iNewDataInfo)
	{	iDataInfo = iNewDataInfo; 
		Data::SetDataNumber(iNewDataNumber);
	}
	int GetInfo() const{ return iDataInfo;}
//============= virtual func for DataList ==============
	int GetCount() const { return 0;}
	Data * GetFirst() const { return 0;}
	Data * GetData() const { return 0;}
	Data * operator[](int) const { return 0;}
	Data * Find(int) const { return 0;}	
	Data * FindAndSet(Data *) const { return 0;}	
	void Find(){ }
	bool Remove(int){ return 0;}
private:
	int iDataInfo;
};

IntData::IntData(int iNewDataNumber, int iNewDataInfo):
	Data(iNewDataNumber),
	iDataInfo(iNewDataInfo)
{ }


//goto class DataNode
class DataNode{
public:
//============= constructor / destructor  ==============
	DataNode(Data *);
	~DataNode();
//============= Set / Get itsNext         ==============
	void SetNext(DataNode * node){ itsNext = node;}
	DataNode * GetNext() const { return itsNext;}
//============= Set / Get itsData         ==============
	Data * GetData() const;
	void SetData(Data * SData){ itsData = SData;}
private:
	Data * itsData;
	DataNode * itsNext;
};

DataNode::DataNode(Data * NewData):
	itsData(NewData),
	itsNext(0)
{ }

DataNode::~DataNode(){
	delete itsData; itsData = 0;
	delete itsNext; itsNext = 0;
}

Data * DataNode::GetData() const{
	if (itsData) return itsData;
	else return NULL; 
}

//list class DataList
class DataList: public Data{
public:
//============= constructor / destructor  ==============
	DataList(int iNewDataNumber);
	DataList(DataList * NewDL,int NewDataNumber);
	~DataList();
//============= GetCount GetFirst GetData ==============
	int GetCount() const { return itsCount;}
	Data * GetFirst() const;
	Data * GetData() const { return pHead->GetData();}
//============= Utilits for work with list =============
	void SetHead(DataNode * NewHead){ NewHead = pHead;}
//======================================================	
	Data * Find(int iDataNumber) const;
	Data * FindAndSet(Data * NewData) const;
//======================================================	
	void Find(int iDataNumber,DataNode * FindNode) const;
	void Insert(Data *);
	bool Remove(int number);
//======================================================	
	void Iterate(void (Data::*func)() const) const;
	void Display() const { 
		printf("\tRow N:"); Data::Display(); printf(": ( ");
		Iterate(&Data::Display); printf(");\n");
	}
	void DisplayList();
//============= peregruzka operatorov      =============
	Data * operator[](int) const;
//============= virtual for IntData        =============
	void SetInfo(int,int) const{ }
	int GetInfo() const { return 0;}
//======================================================
private:
	DataNode * pHead;
	int itsCount;
};

DataList::DataList(int iNewDataNumber):
	pHead(0),
	itsCount(0),
	Data(iNewDataNumber)
{ }

DataList::DataList(DataList * NewDL, int NewDataNumber):
	Data(NewDataNumber)
{
	int NewDN = NewDL->GetData()->GetDataNumber(); 
	if (itsCount == NewDL->GetCount()){
		NewDL->SetHead(pHead);
		pHead->GetData()->SetDataNumber(NewDN);
	} else return;
}

DataList::~DataList()
{
	delete pHead;
}

Data * DataList::GetFirst() const{
	if (pHead) return pHead->GetData();
	else return NULL;
}

Data * DataList::Find(int iDataNumber) const {
	DataNode * pNode = 0;
	for (pNode = pHead; pNode != NULL; pNode = pNode->GetNext()){
		if (pNode->GetData()->GetDataNumber() == iDataNumber)
			break;
	}
	if (pNode == NULL) return NULL;
	else return pNode->GetData();
}

void DataList::Find(int iDataNumber,DataNode * FindNode) const {
	DataNode * pNode = 0;
	for (pNode = pHead; pNode != NULL; pNode = pNode->GetNext()){
		if (pNode->GetData()->GetDataNumber() == iDataNumber)
			break;
	}
	if (pNode == NULL){ FindNode = NULL; return;}
	else{ FindNode = pNode; return;}
}

Data * DataList::FindAndSet(Data * NewData) const {
	DataNode * pNode = 0;
	int NewDataNumber = NewData->GetDataNumber();
	for (pNode = pHead; pNode != NULL; pNode = pNode->GetNext()){
		if (pNode->GetData()->GetDataNumber() == NewDataNumber)
			break;
	}
	if (pNode == NULL) return NULL;
	else {
		pNode->SetData(NewData);
		return pNode->GetData();
	}
}

void DataList::Insert(Data * pData){
	DataNode * pNode = new DataNode(pData);
	DataNode * pCurrent = pHead;
	DataNode * pNext = 0;

	int New = pData->GetDataNumber();
	int Next = 0;
	itsCount++;
	if (!pHead){
		pHead = pNode;
		//perror("Head");
		return;
	}
	int NumHead = pHead->GetData()->GetDataNumber();
	if ( NumHead > New){
		pNode->SetNext(pHead);
		pHead = pNode;
		//perror("NumHead > New");
		return;
	}

	for (;;){
		if (!pCurrent->GetNext() && NumHead < New){
			pCurrent->SetNext(pNode);
			//perror("NumHead < New");
			return;
		}
		
		pNext = pCurrent->GetNext();
		Next = pNext->GetData()->GetDataNumber();
		if (Next > New){
			pCurrent->SetNext(pNode);
			pNode->SetNext(pNext);
			//perror("Next > New");
			return;
		}
		pCurrent = pNext;
	}
}

void DataList::Iterate(void (Data::*func)() const) const{
	if (!pHead) return;
	DataNode * pNode = pHead;
	do
		(pNode->GetData()->*func)();
	while (pNode = pNode->GetNext());
}
void DataList::DisplayList(){
	if (!pHead) return;
	DataNode * pNode = pHead;
	do
		pNode->GetData()->Display();
	while (pNode = pNode->GetNext());
}

bool DataList::Remove(int number){
	if (!Find(number)) return false;

	DataNode * pNode = 0;
	Find(number,pNode);
	pNode->GetData()->Display();
	perror("remove");
	if (pNode == pHead){
		pHead = pHead->GetNext();
		perror("remove beg!");
		return true;
	}
	DataNode * pPrev = pHead;
	while (!pPrev || 
	pPrev->GetData()->GetDataNumber()< number)
	{	pPrev = pPrev->GetNext();}

	if (pNode->GetNext() == NULL){
		pPrev->SetNext(NULL);
		perror("remove end!");
		return true;
	}
	else{
		pPrev->SetNext(pNode->GetNext());
		perror("remove [beg,end]!");
		return true;
	}
	return false;
}

Data * DataList::operator[](int OffSet) const{
	return Find(OffSet);
}

//class Matrix
class Matrix{
public:
	Matrix(){ M = new DataList(0); SizeX = 0; SizeY = 0;}
	~Matrix(){ delete M;}
	void Insert(int x, int y, int z);
	void Print();
	void Print(int x0, int x1, int y0, int y1);
	int Goto(int x, int y) const;	
	int GetSizeX(){ return SizeX;}
	int GetSizeY(){ return SizeY;}
private:
	Data * M;
	int SizeX;
	int SizeY;
};

int Matrix::Goto(int x, int y) const
{
	if (!M->Find(x) || !M->Find(x)->Find(y)){ 
		printf("Goto: A[%d][%d] no Found!\n",x,y); 
		return -1000; 
	}
	else { 
		M->Find(x)->Find(y)->Display();
		return M->Find(x)->Find(y)->GetInfo(); 
	}
}
void Matrix::Insert(int x,int y, int z){
	if (x > SizeX) SizeX = x;
	if (y > SizeY) SizeY = y;
	Data * NewID = new IntData(y,z);
	Data * FindDL = M->Find(x);
	if (!FindDL){
		Data * NewDL = new DataList(x);
		NewDL->Insert(NewID);
		M->Insert(NewDL);
		return;
	}
	Data * FindID = FindDL->Find(y);
	if (!FindID){
		FindDL->Insert(NewID);
		M->FindAndSet(FindDL);
		return;
	}
	else if (FindID && FindDL){
		FindDL->FindAndSet(NewID);
		M->FindAndSet(FindDL);
		return;
	}
}
void Matrix::Print(){
	if ( GetSizeX() == 0 || GetSizeY() == 0)
	{ printf("Print():  Matrix no found.\n"); return;}
	printf("\nPrint Matrix [%dx%d] :\n",GetSizeX(),GetSizeY());
	M->DisplayList();
}
void Matrix::Print(int x0, int x1, int y0, int y1){
	if ( x0 > x1 || y0 > y1 || x0 > GetSizeX() || x1 > GetSizeX()
		|| y0 > GetSizeY() || y1 > GetSizeY())
	{ printf("error: x0 > x1 or y0 > y1 or error GetSize!\n"); return;}
	printf("\nPrint Matrix [%dx%d] :\n",GetSizeX(),GetSizeY());
	for (int x = x0; x != x1+1; x++){
		printf("\tRow N:%d: ( ",x);
		for (int y = y0; y != y1+1; y++)Goto(x,y);
		printf(" );\n");
	}
} 

#endif
==============================================
пишим свои комментарии, если есть желание
прошу оценить работу! - всё таки практически курсовая...

0


Страница 1 из 1
  • Вы не можете создать новую тему
  • Вы не можете ответить в тему

Другие ответы в этой теме

#2 Пользователь офлайн   TRUTHFUL

  • Пользователь
  • PipPip
  • Группа: Модераторы
  • Сообщений: 412
  • Регистрация: 01 Ноябрь 07

Отправлено 10 Июль 2008 - 14:44

Вот зачем ты все сплошным текстом выдал? Есть же специальные теги. И читабельнее будет и нагляднее и люди сразу не закроют страничку :-) Исправь.
Истина где-то рядом... Пускай там и остается!
0

#3 Пользователь офлайн   sawrus

  • Пользователь
  • PipPip
  • Группа: Пользователи
  • Сообщений: 162
  • Регистрация: 07 Ноябрь 07

Отправлено 11 Июль 2008 - 00:01

Просмотр сообщенияTRUTHFUL (10.7.2008, 14:44):

Вот зачем ты все сплошным текстом выдал? Есть же специальные теги. И читабельнее будет и нагляднее и люди сразу не закроют страничку :-) Исправь.



++1 - забыл - торопился
напиши своё мнение о работе пожалуста!
0

#4 Пользователь офлайн   Saray

  • Старожил
  • PipPipPipPipPip
  • Группа: Пользователи
  • Сообщений: 2 388
  • Регистрация: 31 Январь 08

Отправлено 11 Июль 2008 - 07:22

Если честно, не вижу никакого практического применения этого куска красивого ООП, напоминает абстрактный пример из книги и не более того...
на первый взгляд чего явно не хватает в программе:
- функцию в классе Matrix, сохраняющую в файл на диск и загружающую матрицу из файла
- вычисления детерминанта и обратной матрицы
- операций сложения, вычитания, перемножения нескольких матриц (результатом будет являться новый экземпляр класса Matrix)
- поддержки комплексных чисел
- поддержки MML (языка человек-машина) для осуществления этих операций из консоли
тогда и на диплом потянет :rolleyes:
Если женщина не права, нужно извиниться и замолчать.
0

#5 Пользователь офлайн   TRUTHFUL

  • Пользователь
  • PipPip
  • Группа: Модераторы
  • Сообщений: 412
  • Регистрация: 01 Ноябрь 07

Отправлено 11 Июль 2008 - 23:18

Просмотр сообщенияsawrus (11.7.2008, 1:01):

напиши своё мнение о работе пожалуста!

Нормальная, пять :-)
Сейчас без ООП никак.
Истина где-то рядом... Пускай там и остается!
0

#6 Пользователь офлайн   Dr.V1.3

  • Пользователь
  • PipPip
  • Группа: Пользователи
  • Сообщений: 116
  • Регистрация: 15 Ноябрь 07

Отправлено 07 Август 2008 - 23:23

Ктонибуть занимаеться библиотечкой Qt? ^_^
0

#7 Пользователь офлайн   Barrabas

  • Пользователь
  • PipPip
  • Группа: Пользователи
  • Сообщений: 431
  • Регистрация: 01 Ноябрь 07

Отправлено 08 Август 2008 - 14:36

Просмотр сообщенияDr.V1.3 (7.8.2008, 23:23):

Ктонибуть занимаеться библиотечкой Qt? ^_^

я помаленьку на выходных балуюсь PyQT4.3 (биндинг для библиотеки для питона)
0

Страница 1 из 1
  • Вы не можете создать новую тему
  • Вы не можете ответить в тему

1 человек читают эту тему
0 пользователей, 1 гостей, 0 скрытых пользователей