Как хранить разные классы в одной переменной?

У меня есть небольшая концептуальная проблема. У меня есть разные классы, представляющие геометрические данные ребра в зависимости от того, какой это тип ребра. Например, класс для прямой линии и круга:

class Line{
private:
double[3] startPoint;
double[3] endPoint;
public:
//getter and setter and some other functions such as equals

}

class Circle{
private:
double[3] center;
double[3] planeNormal;
double    radius;
public:
//getter and setter and some other functions such as equals
}

Теперь мне нужен класс Edge который хранит тип ребра и подходящие геометрические данные.
В конце концов край должен быть сохранен в std::vector<Edge> edges; Проблема в том, что я не знаю тип до времени выполнения, потому что я анализирую представление границ деталей CAD, которые могут иметь различные типы ребер.

class Edge{
private:
EdgeType type;
GeometricData data;
public:
//...
}

Так, как я должен проектировать свой class Edge и особенно GeometricData который должен хранить либо Line-объект, Circle-объект или другой геометрический объект, так что я могу вернуться из GeometricData в Line, Circle или какой-либо геометрический класс это может быть.

• Я попробовал полиморфизм с GeometricData как базовый класс, но производный
  классы слишком разные, так как такие вещи, как B-сплайны также
  включен.
• Я тоже пробовал GeometricData как void* и шаблонный подход
  для set- и get-метода, но с этим у меня проблемы
  хранение данных, а не только указатель, из-за времени жизни
  объектов (я должен анализировать BRep рекурсивно).

Буду также признателен за предложения, которые могут изменить всю концепцию геометрических представлений, если я смогу получить доступ к данным подбора типов, таким как startPoint прямой или radius круга, используя edges-вектор.

РЕДАКТИРОВАТЬ:
Спасибо за быстрые ответы. Я решил использовать предложение Suszterpatt, включая некоторые из моих шаблонов и изменить мой std::vector<Edge> в std::vector<shared_ptr<Edge>> как сказано в ТАС. Теперь это выглядит так:

#include "stdafx.h"#include <string>
#include <sstream>
#include <iostream>
#include <vector>

using namespace std;

enum EdgeType{
LINE = 100,
CIRCLE
};

//Basis
class GeometricData {
private:
public:
virtual string toXMLString() = 0;
};

class Line : public GeometricData{
//less code just for illustration
private:
double d1;
public:
double getD1() { return d1; }
void setD1(double d1) { this->d1 = d1;}
virtual string toXMLString() {
stringstream s;
s << "d1=\"" << d1 <<"\"";
return s.str();
}
};

class Circle : public GeometricData{
private:
double d2;
public:
double getD2() { return d2; }
void setD2(double d2) { this->d2 = d2;}
virtual string toXMLString() {
stringstream s;
s << "d2=\"" << d2<<"\"";
return s.str();
}
};

class Edge{
private:
EdgeType t;
GeometricData* d;
public:
Edge () { d = 0;}
~Edge () {if (d) {delete d; d=0;}}
template <typename T> int   setGeomData (T data) {
static_assert(
is_same<T,Line*>::value ||
is_same<T,Circle*>::value,
"EdgeGeometryType is not supported");GeometricData* buffer = data;
//set type corresponding to thethis->data given= data

if(is_same<T,Line*>::value){
this->t = LINE;
Line* lb = dynamic_cast<Line*>(buffer);
Line* l = new Line(*lb);
this->d = l;
}else if (is_same<T,Circle*>::value){
this->t = CIRCLE;
Circle* cb = dynamic_cast<Circle*>(buffer);
Circle* c = new Circle(*cb);
this->d = c;
}else{// this case should not occure because of the static_assert
return -1;
}
return 0;

};
template <typename T> T getGeomData () {
static_assert(
is_same<T,Line*>::value ||
is_same<T,Circle*>::value,
"EdgeGeometryType is not supported");

if ((this->t == LINE        && is_same<T,Line*>::value) ||
(this->t == CIRCLE      && is_same<T,Circle*>::value))
{
return dynamic_cast<T>(this->d);
}else{
return NULL;
}
};
EdgeType getType(){ return t; }
//void setType(EdgeType t) { this->t = t; } not needed
GeometricData* getData(){return d;}
};

class Model {
private:
vector <shared_ptr<Edge>> edges;
public:
Model(){}
vector <shared_ptr<Edge>> getEdges(){ return edges; }
void addEdge (Edge* e) {edges.push_back(shared_ptr<Edge>(e));}
shared_ptr<Edge> getEdge(int i ){ return edges.at(i); }
};

// Functions
void foo2 (Edge* e){
Line* l = new Line;
l->setD1(0.1);
e->setGeomData<Line*>(l);
//e->setType(LINE);   not needed
delete l;
}
void foo1 (Edge* e){
Circle c;
c.setD2(0.2);
e->setGeomData<Circle*>(&c);
//e->setType(CIRCLE);  not needed
}
void foo (Model* mdl){
Edge* e1 = new Edge;
Edge* e2 = new Edge;
foo1(e1);
foo2(e2);
mdl->addEdge(e1);
mdl->addEdge(e2);
}
int _tmain(int argc, _TCHAR* argv[])
{
Model mdl;
int i;
foo(&mdl);
cout << "Edge 1: " << mdl.getEdge(0)->getData()->toXMLString() << endl;
cout << "Edge 2: " << mdl.getEdge(1)->getData()->toXMLString() << endl;
for (i = 0; i<2; i++){
switch (mdl.getEdge(i)->getType()){
case LINE: {
Line* ld = (mdl.getEdge(i)->getGeomData<Line*>());
cout << "Line (templated get): " << ld->getD1() << endl;
}break;
case CIRCLE:{
Circle* cr = (mdl.getEdge(i)->getGeomData<Circle*>());
cout << "Circle (templated get): "<< cr->getD2() << endl;
}break;
}
}
return 0;
}