最近C++论坛里面在讨论，点，圆，球的oop实现。具体的讨论见下面的URLhttp://www.csdn.net/expert/topic/772/772272.xml?temp=.4635889。我对jinfeng_wang等讨论的观点持反对的意见。在jinfeng_wang的贴子里面，他为点，圆，球之间赋予了is-a,has-a的关系。并且有些朋友给出了一些解决方案。但是我认为第一，点，圆，球之间的关系真的是is-a,has-a的关系么？这些方案真实体现了现实世界中的点，圆，球的关系了么？如果不是，那么他们的关系如何？？他们的解决方案应该是什么呢？让我先看一个比较完整的方案
interface Point2D
{
virtual int getX()const=0;
virtual int getY()const=0;
};
interface Point3D
{
virtual int getX()const=0;
virtual int getY()const=0;
virtual int getZ()const=0;
};
interface Circle2D
{
virtual int getX()const=0;
virtual int getY()const=0;
virtual int getR()const=0;
};
interface Globe
{
virtual int getX()const=0;
virtual int getY()const=0;
virtual int getZ()const=0;
virtual int getR()const=0;
};
class Globe2Circle: public Circle
{
public:
int getX()const{return g.getX();}
int getY()const{return g.getY();}
int getR()const{return g.getR();}
private:
const Globe& g;
};
Point2D，Point3D的类设计应该没有问题，它可以真实的反映三维和两维的坐标。但是我们看一下Circle2d，它给予我们什么信息呢？三个int变量，他们代表的信息是什么呢？也许自然而然的想法是x,y代表，圆上的坐标，R代表半径。好那么如果我给出下面的实现你能说他是一个圆么?
class Aspect:public Circle2D
{
public:
virtual int getX()const
{
return 100;
}
virtual int getY()const
{
return -100;
}
virtual int getR()
{
return 1;
}}
如果说他是个圆，那这个圆就奇怪了。一个点+一条线就是圆么？(X,Y)是什么？圆上的一点么？如果是那么这个圆的原点在那里？(X,Y)是原点么？如果是，那么圆上的点如何表示呢？另外我能不能说Aspect是一个半圆或者扇形呢？如果Aspect是一个
以(100,100)为圆点R为半径的半圆，那么它能和一个(100,100)为圆点R为半径的圆等价么？即我们能够轻易的给Circle2D加上operator=（）的操作付么？
也许大家有其他的补救办法.能够补救那最好。但是不管如何补救，如果你说你的类是一个圆，那至少要通过下面的验证：给出任意一点（X,y),你的类能不能判断（x,y)在你类定义的圆上。好我们再看圆和球的关系。
class Globe2Circle: public Circle
{
public:
int getX()const{return g.getX();}
int getY()const{return g.getY();}
int getR()const{return g.getR();}
private:
const Globe& g;
};
这个关系告诉我们什么呢？如果我们不仿认为Circle2D的定义是没有问题的。那么他仅仅告诉我们Globe2Circle是一个球在它通过它圆点的
(X,y,z)且z为0上截面的一个投影。如果说这就是圆和球之间的关系的话，那也就太狭隘了。如果是要通过(0,y,z)的截面上的投影又如何表示呢?如果是一个球冠在(x,y,0)上的投影的圆如何表示呢？
点可以说是一个圆，也可以说是一个球。这是常识给我们的错觉，如果我们深究点的特性，点没有面积没有体积，怎么能够说它是一个圆和一个球呢？在解析几何中点的定义为笛卡尔积，所谓笛卡尔积就是一个有序对它第一个元素为有序的n-1的元组（x1,x2...xn-1)，一个笛卡尔积记作((x1,x2..xn-1),x）.什么是圆，即一个二维点的集合，中所有的点到某一个定点的距离都是定长我们称这个点集合为一个圆这个定点称为圆心，定长称为半径。我们记作(x-x0)^2)+(y-y0)^2=R^2。什么是球，即一个三维点的集合，中所有的点到某一个定点的距离都是定长我们称这个点集合为一个球这个定点称为中心，定长称为半径。我们记作(x-x0)^2)+(y-y0)^2+（z-z0)^2=R^2。
其实球（圆）本质上是一系列符合某个函数的点集合。因此要描述一个东西是圆，或者球，那就必须要有三个必要条件，1.圆（球)方程的定义域2.圆（球）方程3.圆（球)方程的值域
那么我在讨论球，圆，点是什么关系呢？我们知道一个球方程 (x-x0)^2)+(y-y0)^2+（z-z0)^2=R^2。只给定一个变量是无法求出其他两个变量的求出的仅仅是一个方程。是一个圆方程。球和圆的关系是，向球输入某一(x,y,z)中的任意一个值m都能给出这个球在平面n=m(n为x,y,z任意一个变量）上的投影。那么反过来给定一个圆，也就是给定了球一个定义域(x-x1)^2+(y-y2)^2=R2^2，可以求出在这个定义域内的所有的
球面上的点。
通俗的讲，点是线在0维坐标上的投影，线是圆在一维坐标上的投影，圆是球在两维坐标上的投影，如果还有四维的话那么球就是四维物体在三维上的投影。也就是说，点就是线的定义域，线是圆的定义域，圆是球的定义域。不管点，线，圆，球都是一个点集合，要表示这个点集合是圆，点，球，那么应该满足一个方程。因此点，线，圆，球不是对象而是算法+数据。当然你可以把数据包装成类，然后采用抽象的方法来访问这些数据，独立的算法给予这些数据以约束。
下面是，我的点，线，圆，球的实现。
#include "stdafx.h"
#include <vector>
#include <map>
#include <exception>
#include <math.h>
using namespace std;
//////////////////////////////////////////////////////////////////////////
//实平面上的点
//////////////////////////////////////////////////////////////////////////
template<int Dem>//点的维度
class Point
{
double meaningless;//没有意义的数值 -1的1/2次方
double __point[Dem];//点坐标
public:
Point()
{
memset(__point,0,Dem);//初始化点作标为原点0
meaningless=pow(-1,0.5);//初始化无意义点
}
Point(double p[Dem])//初始化点作标为p[Dem]中的坐标
{
memcpy(__point,p,Dem);
meaningless=pow(-1,0.5);
}
bool operator <(const Point<Dem> & P)//比较两个点的大小
{
for(int i=0;i<Dem;i++)
{
if(__point[i]<P.__point[i])
return true;
}
return false;
}
bool operator ==(Point<Dem> & P)//判断两点是否等于
{
for(int i=0;i<Dem;i++)
{
if(__point[i]==P.__point[i])
return true;
}
return false;
}
Point<Dem> & operator =(const Point<Dem> & P)//付值Copy
{
for(int i=0;i<Dem;i++)
{
__point[i]==P.__point[i];
}
return (*this);
}
bool IsMeaningless()//是否是无意义的值（如在实平面上的负数开方运算）
{
for(int i=0;i<Dem;i++)
{
double meaningless=pow(-1,0.5);
if(__point[i]==meaningless)
return true;
}
return false
}
double & operator[ ](const int index)//取坐标
{
if(index>Dem)
{
double k=pow(-1,0.5);
return k;
}
else
return __point[index];
}
};
template <int Dem>
bool operator <(const Point<Dem> & P1,const Point<Dem> & P2)
{
for(int i=0;i<Dem;i++)
{
Point<Dem> &p1=(Point<Dem>&) P1;
Point<Dem> &p2=(Point<Dem>&) P2;
if(p1[i]<p2[i])
return true;
}
return false;
}
template<>
class Point<0>//对0维坐标系的特化
{
double meaningless;
double __point[1];
public:
Point()
{
__point[0]=0.0;
meaningless=pow(-1,0.5);
}
Point(double p)
{
__point[0]=p;
meaningless=pow(-1,0.5);
}
bool operator <(const Point<Dem> & P)
{
if(__point[0]<P.__point[0])
return true;
else return false;
}
bool operator ==(Point<0> & P)
{
if(__point[0]==P.__point[0])
return true;
else return false;
}
Point<0> & operator =(const Point<0> & P)
{
__point[0]=P.__point[0];
return (*this);
}
bool IsMeaningless()
{
double meaningless=pow(-1,0.5);
if(__point[0]==meaningless)
return true;
else
return false;
}
double & operator[ ](const int index)
{
if(index>0)
{
double k=pow(-1,0.5);
return k;
}
else
return __point[index];
}
};
bool operator <(const Point<0> & P1,const Point<0> & P2)
{
int i=0;
Point<0> &p1=(Point<0>&) P1;
Point<0> &p2=(Point<0>&) P2;
if(p1[i]<p2[i])
return true;
else return false;
}
template<int Dem>
class Reference_frame//坐标系
{
int Demsionsize;//维度
Point<Dem> __OriginPoint;//坐标原点
public:
Reference_frame()
{
if(Dem<1)//如果维度小于1报错
{
exception e;
throw e;
}
Demsionsize=Dem;
}
};
template<int Dem,typename Shift,int DDem=Dem-1>
class Aspect:public Reference_frame<Dem>//在一定坐标系下的点集之间的映射（目前是满单射）
{
vector<Point<DDem> > __DPointSet;//定义域
multimap<Point<DDem>,Point<Dem> > __VPointSet; //值域
Shift * __Shift;//变换函数
struct IterAdaptor
{
multimap<Point<DDem> ,Point<Dem> >::iterator &iterator;
friend class IterAdaptor;
public:
IterAdaptor(multimap<Point<DDem> ,Point<Dem> >::iterator &it):iterator(it)
{
}
IterAdaptor(IterAdaptor &ita):iterator(ita.iterator)
{
}
IterAdaptor & operator ++()
{
return IterAdaptor(++iterator);
}
IterAdaptor & operator --()
{
return IterAdaptor(--iterator);
}
IterAdaptor & operator =(multimap<Point<DDem> ,Point<Dem> >::iterator &it)
{
return IterAdaptor(it);
}
IterAdaptor & operator =(IterAdaptor &it)
{
this->iterator=it;
return (*this);
}
Point<Dem> & operator * ()
{
return (*iterator).second;
}
bool operator==(IterAdaptor &it)
{
return iterator==it.iterator;
}
bool operator!=(IterAdaptor &it)
{
return (!((*this)==it));
}
};
public:
typedef vector<Point<DDem> >::iterator __Defiterator;
typedef IterAdaptor iterator;
template<typename _A,typename ParamType>
Aspect(_A & PointSet,ParamType & Param)//构造函数传入定义域和，映射需要的参数
{
__Shift=new Shift(Param);
_A::iterator it= PointSet.begin();
for(;it!=PointSet.end();it++)
{
Point<DDem> p=(*it);
__DPointSet.push_back(p);
}
BuildValue();
}
template<typename _A>
Aspect(_A & PointSet)
{
__Shift=new Shift;
_A::iterator it= PointSet.begin();
for(;it!=PointSet.end();it++)
{
Point<DDem> p=(*it);
__DPointSet.push_back(p);
}
BuildValue();
}
Aspect()
{
__Shift=new Shift;
}
~Aspect()
{
delete __Shift;
}
SetDefinition(vector<Point<DDem> > & PointSet )
{
__DPointSet =PointSet;
BuildValue();
}
__Defiterator Dbegin()//得到定义域的上限
{
return __DPointSet.begin();
}
__Defiterator Dend()//等到定义域的下限
{
return __DPointSet.end();
}
iterator begin()//得到值域的上限
{
return IterAdaptor(__VPointSet.begin());
}
iterator end()//得到值义域的下限
{
return IterAdaptor(__VPointSet.end());
}
protected:
BuildValue()//从定义域到值域的映射
{
__Defiterator it=Dbegin();
for(;it!=Dend();it++)
{
Point<Dem> temp;
temp= (*__Shift)((*it));
__VPointSet.insert(multimap<Point<DDem>,Point<Dem> >::value_type((*it),temp));
}
}
};
class line//y=0的一元一次函数的映射类
{
public:
line()
{
}
Point<1> & operator()(Point<0> &point)
{
Point<1> temp;
temp[0]=point[0];
return temp;
}
};
template<int Dem>
class CircleParam//球或圆的参数（Dem=2为圆，Dem=3为球）
{
protected:
int __radius;//半径
Point<Dem> __Circle_Centre;//圆心（球心）
public:
CircleParam(int r,Point<Dem> O)
{
if(Dem>3||Dem<2)
{
exception e;
throw e;
}
__radius=r;
__Circle_Centre=O;
}
CircleParam()
{
__radius=0;
}
CircleParam<Dem> & operator=(CircleParam<Dem> Center )
{
__radius=Center.__radius;
__Circle_Centre=Center.__Circle_Centre;
return (*this);
}
};
class circle:public CircleParam<2>//圆
{
public:
circle(CircleParam<2> & Param)
{
(CircleParam<2>)(*this)=Param;
}
Point<2> operator()(Point<1> point)
{
double r_sqr=__radius*__radius;
double x_sqr=(point[0]-__Circle_Centre[0])*(point[0]-__Circle_Centre[0]);
double y=pow(r_sqr-x_sqr,0.5);
Point<2> tmp;
tmp[0]=point[0];
tmp[1]=y;
return tmp;
}
};
class ball:public CircleParam<3>//球
{
public:
ball(CircleParam<3> & Param)
{
(CircleParam<3>)(*this)=Param;
}
Point<3> operator()(Point<2> point)
{
double r_sqr=__radius*__radius;
double x_sqr=(point[0]-__Circle_Centre[0])*(point[0]-__Circle_Centre[0]);
double y_sqr=(point[1]-__Circle_Centre[1])*(point[1]-__Circle_Centre[1]);
double z=pow(r_sqr-x_sqr-y_sqr,0.5);
Point<3> tmp;
tmp[0]=point[0];
tmp[1]=point[1];
tmp[0]=z;
return tmp;
}
};
int main(int argc, char* argv[])
{
double z=pow(-4,0.5);
typedef Point<0> P0;
typedef Point<1> P1;
typedef Point<2> P2;
typedef Point<3> P3;
vector<Point<0> > _LDef;
_LDef.push_back(P0(0));
_LDef.push_back(P0(1));
_LDef.push_back(P0(2));
_LDef.push_back(P0(3));
_LDef.push_back(P0(4));
_LDef.push_back(P0(5));
double param;
Aspect<1,line> Line(_LDef);//线（离散的线)
double p2[2]={0.0,0.0};
CircleParam<2> Cp2(100,P2(p2));
double p3[3]={0.0,0.0,0.0};
CircleParam<3> Cp3(100,P3(p2));
Aspect<2,circle> Circle(Line,Cp2);//以Line为定义域的圆（离散的圆）
Aspect<3,ball> Ball(Circle,Cp3);//以Circle为定义域的球（离散的球）
return 0;
}
