I made a program that prints dots and lines in a Page. So far that's all i could come up with.
When i try to print the lines and the dots it just prints consecutive points,I want it to print the points & lines in the page's coordinates.
I have been stuck for a long time now. Please Help.
Point.h
Code :
#pragma once
#include <iostream>
using namespace std;
class Point
{
private:
int x;
int y;
public:
Point(void);
Point( int x, int y );
Point( const Point &xPoint );
~Point(void);
void setX( int x );
int getX() const;
void setY( int y );
int getY() const;
Point & operator = ( const Point &xPoint );
bool operator == ( const Point &xPoint ) const;
bool includes( int cord_X, int cord_Y ) const;
bool includes( const Point &xPoint ) const;
void draw() const;
};
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Point.cpp
Code :
#include "Point.h"
Point::Point( void )
{
this->x = 0;
this->y = 0;
}
Point::Point( int x, int y )
{
this->x = x;
this->y = y;
}
Point::Point( const Point &xPoint )
{
this->x = xPoint.x;
this->y = xPoint.y;
}
Point::~Point( void ) {}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
void Point::setX( int x ) // set X
{
this->x = x;
}
void Point::setY( int y ) // set Y
{
this->y = y;
}
int Point::getX() const // get X
{
return ( this->x );
}
int Point::getY() const // get Y
{
return ( this->y );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Point &Point::operator = ( const Point &xPoint )
{
if( this != &xPoint )
{
this->x = xPoint.x;
this->y = xPoint.y;
}
return ( *this );
}
bool Point::includes( int cord_X, int cord_Y ) const
{
return ( this->x == cord_X && this->y == cord_Y );
}
void Point::draw() const
{
cout << '.';
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
bool Point::operator == ( const Point &xPoint ) const
{
bool isEquality = false;
if( this->x == xPoint.x && this->y == xPoint.y )
{
isEquality = true;
}
return isEquality;
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
PointCollection.h
Code :
#pragma once
#include "Point.h"
const int MAXPoint = 100;
class PointCollection
{
private:
Point pts[ MAXPoint ];
int quantity;
public:
PointCollection( void );
PointCollection( const PointCollection &xPointCollection );
~PointCollection( void );
// To know how many Points are
// ..in the collection
int size() const;
PointCollection operator = ( const PointCollection &xPointCollection );
PointCollection &operator + ( const Point &xPoint );
Point &operator[]( int index );
const Point &operator[]( int index ) const;
bool isFull() const;
bool isEmpty() const;
bool includes( const Point &xPoint ) const;
int indexOf( const Point &xPoint ) const;
};
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
PointCollection.cpp
Code :
#include "PointCollection.h"
PointCollection::PointCollection( void )
{
this->quantity = 0;
}
PointCollection::PointCollection( const PointCollection &xPointCollection )
{
this->quantity = xPointCollection.quantity;
for ( int i = 0 ; i < this->quantity ; i++ )
( this->pts )[ i ] = ( xPointCollection.pts )[ i ];
}
PointCollection::~PointCollection( void ) {}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
int PointCollection::size() const
{
return ( this->quantity );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Point &PointCollection::operator []( int index )
{
return ( ( this->pts )[ index ] );
}
const Point &PointCollection::operator []( int index ) const
{
return ( ( this->pts )[ index ] );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
PointCollection PointCollection::operator =( const PointCollection &xPointCollection )
{
this->quantity = xPointCollection.quantity;
for ( int i = 0 ; i < this->quantity ; i++ )
( this->pts )[ i ] = ( xPointCollection.pts )[ i ];
return ( *this );
}
PointCollection &PointCollection::operator +( const Point &xPoint )
{
(*this)[ this->quantity ] = xPoint;
(this->quantity)++;
return ( *this );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
bool PointCollection::isFull() const
{
return ( this->quantity == MAXPoint );
}
bool PointCollection::isEmpty() const
{
return ( this->quantity == 0 );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
bool PointCollection::includes( const Point &xPoint ) const
{
bool thisOne = false;
for ( int i = 0 ; i < this->quantity && ! thisOne ; i++ )
{
if( pts[ i ] == xPoint )
thisOne = true;
}
return ( thisOne );
}
int PointCollection::indexOf( const Point &xPoint ) const
{
int index = -1;
for ( int i = 0 ; i < this->quantity && index == -1 ; i++ )
{
if( pts[ i ] == xPoint )
index = i;
}
return ( index );
}
Line.h
Code :
#pragma once
#include "Point.h"
class Linea
{
private:
Point begin;
Point end;
public:
Linea( void );
Linea( const Linea &xLinea );
Linea( Point XY1, Point XY2 );
~Linea( void );
Linea &operator = ( const Linea &xLinea );
bool includes( int cord_X, int cord_Y ) const;
bool operator == ( const Linea &xLinea ) const;
double m() const; // Pendiente
double b() const; // Intercept in Y
bool isVertical() const;
bool isHorizontal() const;
bool isDiagonal() const;
void draw() const;
};
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Line.cpp
Code :
#include "Linea.h"
Linea::Linea()
{
}
Linea::Linea( Point XY1, Point XY2 )
{
this->begin = begin;
this->end = end;
}
Linea::Linea( const Linea &xLinea )
{
this->begin = xLinea.begin;
this->end = xLinea.end;
}
Linea::~Linea( void )
{
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Linea &Linea::operator =( const Linea &xLinea )
{
if( this != &xLinea )
{
this->begin = xLinea.begin;
this->end = xLinea.end;
}
return ( *this );
}
bool Linea::operator == ( const Linea &xLinea ) const
{
bool isEquality = false;
if( this->begin == xLinea.begin &&
this->end == xLinea.end )
{
isEquality = true;
}
return isEquality;
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
double Linea::m()const
{
return ( (this->end.getY()) - (this->begin.getY()) ) / ((this->end.getX()) - (this->begin.getX()) );
}
double Linea::b()const
{
return ( this->end.getY() - (this->m() * this->end.getX()) );
}
bool Linea::isVertical () const
{
return ( ( (this->end.getX()) - (this->begin.getX()) ) == 0 );
}
bool Linea::isHorizontal () const
{
return ( ( (this->end.getY()) - (this->begin.getY()) ) == 0 );
}
bool Linea::isDiagonal () const
{
return ( this->isVertical() && this->isHorizontal() );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
bool Linea::includes( int cord_X, int cord_Y ) const
{
bool included = false;
if ( this->isHorizontal() )
{
if ( ( (this->begin).getY() == cord_Y ) &&
( (this->begin).getX() <= cord_X ) &&
( (this->end).getX() >= cord_X ) ||
( (this->begin).getX() >= cord_X ) &&
( (this->end).getX() <= cord_X ) )
included = true;
}
else if ( this->isVertical() )
{
if ( ( (this->begin).getX() == cord_X ) &&
( (this->begin).getY() <= cord_Y ) &&
( (this->end).getY() >= cord_Y ) ||
( (this->begin).getY() >= cord_Y ) &&
( (this->end).getY() <= cord_Y ) )
included = true;
}
else
{
if ( ( cord_Y == this->m() * cord_X + this->b() ) &&
( (this->begin).getX() <= cord_X ) &&
( (this->end).getX() >= cord_X ) ||
( (this->begin).getX() >= cord_X ) &&
( (this->end).getY() >= cord_Y ) ||
( (this->begin).getY() >= cord_Y ) &&
( (this->end).getY() <= cord_Y ) )
included = true;
}
return ( included );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
void Linea::draw() const
{
cout << '.';
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
LineCollectoin.h
Code :
#pragma once
#include "Linea.h"
const int MAX = 100;
class LineCollection
{
private:
Linea lc[ MAX ];
int quantity;
public:
LineCollection(void);
LineCollection( const LineCollection &xLineCollection );
~LineCollection(void);
// To know how many Lines are
// ..in the collection
int size() const;
LineCollection operator = ( const LineCollection &xLineCollection );
LineCollection &operator + ( const Linea &xLinea );
Linea &operator [] ( int index );
const Linea &operator[]( int index ) const;
bool isFull() const;
bool isEmpty() const;
bool includes( const Linea &xLinea ) const;
int indexOF( const Linea &xLinea ) const;
friend ostream &operator << ( ostream &output, const LineCollection &xLineCollection );
friend istream &operator >> ( istream &input, LineCollection &xLineCollection );
};
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
LineCollection.cpp
Code :
#include "LineCollection.h"
LineCollection::LineCollection( void )
{
this->quantity = 0;
}
LineCollection::LineCollection( const LineCollection &xLineCollection )
{
this->quantity = xLineCollection.quantity;
for ( int i = 0 ; i < this->quantity ; i++ )
( this->lc )[ i ] = ( xLineCollection.lc )[ i ];
}
LineCollection::~LineCollection( void ) {}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
int LineCollection::size() const
{
return ( this->quantity );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Linea &LineCollection::operator []( int index )
{
return ( ( this->lc )[ index ] );
}
const Linea &LineCollection::operator []( int index ) const
{
return ( ( this->lc )[ index ] );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
LineCollection LineCollection::operator =( const LineCollection &xLineCollection )
{
this->quantity = xLineCollection.quantity;
for ( int i = 0 ; i < this->quantity ; i++ )
( this->lc )[ i ] = ( xLineCollection.lc )[ i ];
return ( *this );
}
LineCollection &LineCollection::operator +( const Linea &xLinea )
{
(*this)[ this->quantity ] = xLinea;
(this->quantity)++;
return ( *this );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
bool LineCollection::isFull() const
{
return ( this->quantity == MAX );
}
bool LineCollection::isEmpty() const
{
return ( this->quantity == 0 );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
bool LineCollection::includes(const Linea &xLinea) const
{
bool thisOne = false;
for ( int i = 0 ; i < this->quantity && ! thisOne ; i++ )
{
if ( lc[i] == xLinea )
thisOne = true;
}
return ( thisOne );
}
int LineCollection::indexOF( const Linea &xLinea ) const
{
int index = -1;
for ( int i = 0 ; i < this->quantity && index == -1 ; i++ )
{
if ( lc[i] == xLinea )
index = i;
}
return ( index );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Page.h
Code :
#pragma once
#include "PointCollection.h"
#include "LineCollection.h"
const int MAXPAGE = 100;
class Page
{
private:
int heigh;
int width;
public:
Page( void );
Page( int width, int heigh );
Page( const Page &xPage );
~Page( void );
void setWidth( int width );
int getWidth() const;
void setHeigh( int heigh );
int getHeigh() const;
bool operator == ( const Page &xPage ) const;
void draw() const;
};
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Page.cpp
Code :
#include "Page.h"
Page::Page( void )
{
this->width = 0;
this->heigh = 0;
}
Page::Page( int width, int heigh )
{
this->width = width;
this->heigh = heigh;
}
Page::Page( const Page &xPage )
{
this->width = xPage.width;
this->heigh = xPage.heigh;
}
Page::~Page( void ) {}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
void Page::setHeigh( int heigh )
{
this->heigh = heigh;
}
void Page::setWidth( int width )
{
this->width = width;
}
int Page::getHeigh() const
{
return ( this->heigh );
}
int Page::getWidth() const
{
return ( this->width );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
void Page::draw() const
{
bool included;
PointCollection pc;
LineCollection li;
for( int y = 0 ; y < this->heigh ; y++ )
{
included = false;
for ( int x = 0; x < this->width ; x++ )
{
for ( int p = 0 ; p < pc.size() && !included ; p++ )
{
if ( pc[ p ].includes( x, y ) )
{
pc[ p ].draw();
included = true;
}
if ( included )
cout << ' ';
}
for ( int line = 0 ; line < li.size() && !included ; line++ )
{
if ( li[ line ].includes( x, y ) )
{
li[ line ].draw();
included = true;
}
if ( included )
cout << ' ';
}
}
cout << endl;
}
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
bool Page::operator ==( const Page &xPage ) const
{
bool isEquality = false;
if( this->heigh == xPage.heigh && this->width == xPage.width )
{
isEquality = true;
}
return isEquality;
}
Main.cpp
Code :
#include "Page.h"
int main ()
{
Point p1( 5, 5 ), p2( 1, 1 );
Linea L;
Page pg( 15, 15 );
p1.draw();
pg.draw();
/*
if ( p1.includes( 1, 1 ) == true )
cout << "Point 1 & 2 are Equal" << "\n\n";
else
cout << "Point 1 & 2 are NOT Equal" << "\n\n";
*/
system("PAUSE");
return 0;
}