C / C++ / MFC

//inherit/coord.hpp
#ifndef COORD_HPP
#define COORD_HPP

//header file for i/o
#include <iostream>

namespace Geo		//*****BEGIN namespace Geo*****
{
	
	/*class Coord
	 *- auxiliary class for geometric objects
	 *- not suitable for inheritance
	 */
	class Coord
	{
	private:
		int x;		//X coordinate
		int y;		//Y coordinate
	
	public:
		//default constructor, and two-paramter constructor
		Coord() : x(0), y(0)		//default values:0
		{
		}
		Coord(int newx, int newy) : x(newx), y(newy)
		{
		}

		Coord operator + (const Coord&) const;		//addition
		Coord operator - () const;					//negative
		void operator += (const Coord&);			//addition assignment
		void printOn(std::ostream& strm) const;		//output
	};

	/*operator +
	 *- add X and Y coordinates
	 */
	inline Coord Coord::operator + (const Coord& p) const
	{
		return Coord(x+p.x, y+p.y);
	}

	/*unary operator
	 *- negative X and Y coordinates
	 */
	inline Coord Coord::operator -() const
	{
		return Coord(-x, -y);
	}
	/*operator +=
	 *- output coordinates as a pair of values
	 */
	inline void Coord::printOn(std::ostream& strm) const
	{
		strm << '(' << x << ',' << y << ')';
	}

	/*operator <<
	 *- conversion for standard output operator
	 */
	inline std::ostream& operator << (std::ostream& strm, const Coord& p)
	{
		p.printOn(strm);
		return strm;
	}

}			//*****END namespace Geo*****

#endif		//COORD_HPP

//inherit/geoobj.hpp
#ifndef	GEOOBJ_HPP		
#define GEOOBJ_HPP

//header file for coordinates
#include "geo.hpp"

namespace Geo
{
	/*abstract base class GeoObj
	 *	- common base class for geometric objects
	 *	- provided for inheritance
	 */
	
	class GeoObj
	{
	protected:
		//every GeoObj has a reference point
		Coord refpoint;

		/*constructor for an initial reference point
		 *	- not public
		 *	- there is no default constructor available
		 */

		GeoObj(const Coord& p) : refpoint(p)
		{
		}

	public:
		//move geometric object according to passes relative offset
		virtual void move(const Coord& offset)
		{
			refpoint += offset;
		}

		/*draw geometric object
		 *	- pure virtual function
		 */
		virtual void draw() const = 0;

		//virtual destructor
		virtual ~GeoObj()
		{
		}
	};
}	//*****END namesapce Geo*****

#endif		//GEOOBJ_HPP

//inherit/circle.hpp
#ifndef CIRCLE_HPP
#define CIRCLE_HPP

//haderfile for Input and output
#include <iostream>

//include header file for the base class geoobj.hpp
#include "geo.hpp"

namespace Geo
{
	/*class Circle
	 *	- Derived from GeoObj
	 *	- A circle consists of:
	 *		- a center point (reference point, inherited)
	 *		- a radius (new)
	 */
	class Circle : public GeoObj
	{
	protected:
		unsigned radius;		//radius

	public:
		//constructor for center point and radius
		Circle(const Coord& m, unsigned r)
			: GeoObj (m), radius(r)
		{

		}

		//draw geometric object (now implemented)
		virtual void draw() const;

		//virtual destructor
		virtual ~Circle()
		{

		}
	};

	/*drawing
	 *	- defined inline
	 */
	inline void Circle::draw() const
	{
		std::cout << "Circle around center point " << refpoint << " with radius " << radius << std::endl;
	}
}		//*****END namespace Geo*****
#endif	//end CIRCLE_HPP	

//inherit/line.hpp
#ifndef LINE_HPP
#define LINE_HPP

//header file for I/O
#include <iostream>

//header file of the base class
#include "geo.hpp"

namespace Geo
{
	/*class Line
	 *	-Derived from GeoObj
	 *	-A line consists of:
	 *		-a start point (refernce point, inherited)
	 *		-an end point (new)
	 */
	class Line : public GeoObj
	{
	protected:
		Coord p2;		//second point, end point

	public:
		//constructor for start and end points
		Line(const Coord& a, const Coord& b)
			:GeoObj(a), p2(b)
		{
		}

		//draw geometric object (now implemented)
		virtual void draw() const;

		//move geometric object(reimplemented)
		virtual void move(const Coord&);

		//virtual destructor
		virtual ~Line()
		{
		}
	};
	/*output
	 *	-defined inline
	 */
	inline void Line::move(const Coord& offset)
	{
		refpoint += offset;		//represents GeoObj::move(offset);
		p2 += offset;
	}
}		//*****END namesapce Geo*****

#endif		//LINE_HPP

//inherit/geotest1.cpp

//header file for used classes
#include "geo.hpp"

//forward declaration
void printGeoObj(const Geo::GeoObj&);

int main()
{
	Geo::Line l1(Geo::Coord(1,2), Geo::Coord(3,4));
}