2. Формальная постановка задачи
11. Треугольник, трапеция, текст, текст в трапеции
14. Множество на базе массива
3. Ход выполнения работы
1. Разработка программ в среде MS Visual C++.
Настройка среды. Выполнение индивидуального задания.
Откомпилировала и выполнила проект TrialRun.
Иерархия классов представлена на рисунке 1.
Базовый чисто абстрактный класс Shapeопределяет интерфейс.
Класс Positionреализует некоторые методы интерфейса и определяет методы работы с заданием и изменением позиции в рабочей области.
Наследование CTriangleEntity и CTextEntity от CPointEntity и CTrapeziumEntity от CTriangleEntity сделано виртуальным.
Класс CTextTrapeziumEntity множественно наследован от CTrapeziumEntity и CTextEntity. Виртуальное наследование позволяет избежать двойного включения базового класса.
Определения всех классов находятся в файлах с расширением .h, определение - .cpp.
Текст классов и тестовой программы:
class Shape
#pragma once
#include <iomanip>
//базовый класс
class Shape
{
public:
virtual void Printfig(std::ostream& os)=0;
virtual int getX() const=0;
virtual int getY() const=0;
virtual void setX(int _X)=0;
virtual void setY(int _Y)=0;
virtual void move(int dx,int dy)=0;
virtual ~Shape(){}
private:
friend std::ostream& operator<<(std::ostream& os,Shape* ob)
{ob->Printfig(os);
return os;}
};
class CPointEntity.h
#pragma once
#include "Shape.h"
/********************************************************************************/
//класс - позиция
class CPointEntity :virtual public Shape
{
protected:
int mX;
int mY;
public:
CPointEntity( const int iX = 0, const int iY = 0 );
virtual ~CPointEntity();
int getX() const;
int getY() const;
void setX(int iX );
void setY(int iY );
void move(int dx,int dy);
void Printfig(std::ostream& os);
};
CPointEntity.cpp
#include <iostream>
/********************************************************************************/
CPointEntity::CPointEntity( const int iX, const int iY )
{
setX( iX );
setY( iY );
}
/********************************************************************************/
CPointEntity::~CPointEntity()
{
}
/********************************************************************************/
int CPointEntity::getX() const
{
return mX;
}
/********************************************************************************/
int CPointEntity::getY() const
{
return mY;
}
/********************************************************************************/
void CPointEntity::setX( const int iX )
{
mX = iX;
}
/********************************************************************************/
void CPointEntity::setY( const int iY )
{
mY = iY;
}
/********************************************************************************/
void CPointEntity::move(int dx,int dy)
{
mX=mX+dx;
mY=mY+dy;
}
void CPointEntity::Printfig(std::ostream& os)
{
os << "Point:"<<std::endl;
os << " X=" <<mX<<std::endl;
os << " Y=" <<mY<<std::endl;
}
class CTriangleEntity.h
#pragma once
#include "CPointEntity.h"
class CTriangleEntity :
virtual public CPointEntity
{
protected:
int mBase;
int mHeight;
public:
CTriangleEntity( const int iB = 10, const int iH = 10,
const int iX = 0, const int iY = 0 );
virtual ~CTriangleEntity();
int getBase() const;
int getHeight() const;
void setBase( int iB );
void setHeight( int iH );
void Printfig(std::ostream& os);
};
CTriangleEntity.cpp
/********************************************************************************/
#include "TriangleEntity.h"
#include <iostream>
/********************************************************************************/
CTriangleEntity::CTriangleEntity( const int iB, const int iH,
const int iX, const int iY )
:CPointEntity( iX,iY )
{
setBase( iB );
setHeight( iH );
}
/********************************************************************************/
CTriangleEntity::~CTriangleEntity()
{
}
/********************************************************************************/
int CTriangleEntity::getBase() const
{
return mBase;
}
/********************************************************************************/
int CTriangleEntity::getHeight() const
{
return mHeight;
}
/********************************************************************************/
void CTriangleEntity::setBase( int iB )
{
mBase = iB;
}
/********************************************************************************/
void CTriangleEntity::setHeight( int iH )
{
mHeight = iH;
}
/********************************************************************************/
void CTriangleEntity::Printfig(std::ostream& os)
{
os << "Triangle:" <<std::endl;
os << " X=" << mX<<std::endl;
os << " Y=" << mY<<std::endl;
os << " B=" << mBase<<std::endl;
os << " H=" << mHeight<<std::endl;
}
/********************************************************************************/
class CTrapeziumEntity.h
#pragma once
#include "TriangleEntity.h"
/********************************************************************************/
class CTrapeziumEntity :
virtual public CTriangleEntity
{
protected:
int mCutoff;
public:
// необходимо указывать все параметры
// точки, треугольника, да ещё и параметр среза
CTrapeziumEntity( const int iC,
const int iB, const int iH,
const int iX = 0, const int iY = 0 );
virtual ~CTrapeziumEntity();
int getCutoff() const;
// функция для задания среза
void setCutoff( int iC );
void Printfig(std::ostream& os);
};
CTrapeziumEntity.cpp
/********************************************************************************/
#include "TrapeziumEntity.h"
#include <iostream>
/********************************************************************************/
CTrapeziumEntity::CTrapeziumEntity( const int iC,
const int iB, const int iH,
const int iX, const int iY )
: CPointEntity(iX, iY),
CTriangleEntity(iB, iH, iX, iY)
{
setCutoff( iC );
}
/********************************************************************************/
CTrapeziumEntity::~CTrapeziumEntity()
{
}
/********************************************************************************/
int CTrapeziumEntity::getCutoff() const
{
return mCutoff;
}
/********************************************************************************/
void CTrapeziumEntity::setCutoff( int iC )
{
mCutoff = (iC > 0)? (iC < mHeight)? iC : mHeight : 0;
}
/********************************************************************************/
void CTrapeziumEntity::Printfig(std::ostream& os)
{
os << "Trapezium:"<<std::endl;
os << " X=" << mX<<std::endl;
os << " Y=" << mY<<std::endl;
os << " B=" << mBase<<std::endl;
os << " C=" << mCutoff<<std::endl;
}
/********************************************************************************/
class CTextEntity.h
#pragma once
#include "CPointEntity.h"
#include <string>
class CTextEntity :
virtual public CPointEntity
{
protected:
std::string mText;
public:
// Создаёт текст в заданной точке.
CTextEntity( const std::string iT,
const int iX = 0, const int iY = 0 );
virtual ~CTextEntity();
std::string getText() const;
void setText( const std::string iT );
void Printfig(std::ostream& os);
};
CTextEntity.cpp
/********************************************************************************/
#include "TextEntity.h"
#include <iostream>
/********************************************************************************/
CTextEntity::CTextEntity( const std::string iT,
const int iX, const int iY)
: CPointEntity(iX, iY)
{
setText( iT );
}
/********************************************************************************/
CTextEntity::~CTextEntity()
{
// Интересно, а надо ли как-нибудь удалять эту строку?
}
/********************************************************************************/
std::string CTextEntity::getText() const
{
return mText;
}
/********************************************************************************/
void CTextEntity::setText( const std::string iT )
{
mText = iT;
}
/********************************************************************************/
void CTextEntity::Printfig(std::ostream& os)
{
os << "Text:" <<std::endl;
os << " X=" << mX<<std::endl;
os << " Y=" << mY<<std::endl;
os << " T=" << mText<<std::endl;
}
/********************************************************************************/
class CTextTrapeziumEntity.h
#pragma once
#include "TextEntity.h"
#include "TrapeziumEntity.h"
/********************************************************************************/
class CTextTrapeziumEntity :
virtual public CTrapeziumEntity,
virtual public CTextEntity
{
public:
CTextTrapeziumEntity( const std::string iT, const int iC,
const int iB, const int iH,
const int iX = 0, const int iY = 0 );
virtual ~CTextTrapeziumEntity();
void Printfig(std::ostream& os);
int getX() const;
int getY() const;
void setX(int iX );
void setY(int iY );
void move(int dx,int dy);
};
CTextTrapeziumEntity.cpp
#include "TextTrapeziumEntity.h"
#include <iostream>
/********************************************************************************/
CTextTrapeziumEntity::CTextTrapeziumEntity( const std::string iT, const int iC,
const int iB, const int iH,
const int iX, const int iY )
: CPointEntity(iX, iY),
CTriangleEntity(iB, iH, iX, iY),
CTrapeziumEntity(iC, iB, iH, iX, iY),
CTextEntity(iT, iX, iY)
{
// Разумного объяснения, почему надо делать как-то так, у меня нет. MSDN говорит,
// что необходимо явно инициализировать родительские классы сверх первого в случае
// виртуального наследования
}
/********************************************************************************/
CTextTrapeziumEntity::~CTextTrapeziumEntity()
{
}
/********************************************************************************/
void CTextTrapeziumEntity::Printfig(std::ostream& os)
{
os << "TextTrapezium:"<<std::endl;
os << " X=" << getX()<<std::endl;
os << " Y=" << getY()<<std::endl;
os << " B=" << mBase<<std::endl;
os << " H=" << mHeight<<std::endl;
os << " C=" << mCutoff<<std::endl;
os << " T=" << mText<<std::endl;
}
int CTextTrapeziumEntity::getX() const
{return CTrapeziumEntity::getX();}
int CTextTrapeziumEntity::getY() const
{return CTrapeziumEntity::getY();}
void CTextTrapeziumEntity::setX(int iX )
{CTrapeziumEntity::setX(iX);}
void CTextTrapeziumEntity::setY(int iY )
{CTrapeziumEntity::setY(iY);}
void CTextTrapeziumEntity::move(int dx,int dy)
{CTrapeziumEntity::move(dx,dy);}
В базовом классе переопределен оператор добавления в поток <<.
В операторе << вызывается виртуальная функция display, изменяющая состояние потока. Эта функция переопределяется во всех наследованных классах, что позволяет каждому классу добавлять в поток свою информацию.
Работа в режиме отладки.
Просмотреть работу программы по шагам, расставив точки останова. И запустив программу в режиме отладки (Build -> Start Debug -> Go).