2

少し概念的な問題があります。エッジの種類に応じて、エッジの幾何学的データを表すさまざまなクラスがあります。たとえば、直線と円のクラス:

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:
    //...
}

では、オブジェクト、オブジェクト、または別の幾何学的オブジェクトのいずれかを格納する必要がある my class Edgeand espaciallyをどのように設計すればよいのでしょうか。GeometricDataLineCircleGeometricDataLineCircle

  • 基底クラスとしてポリモーフィズムを試みGeometricDataたのですが、B-Splines なども含まれているため、派生クラスが違いすぎます。
  • set メソッドと get メソッドの as とテンプレート アプローチも試しましたが、オブジェクトの有効期間のため、ポインターだけでなくデータの保存にも問題があります (BRep を再帰的に分析する必要がありますGeometricData) 。void*

startPointベクトルを使用して直線やradius円などのタイプフィッティングデータにアクセスできる限り、幾何学的表現の概念全体を変更する可能性のある提案もedgesいただければ幸いです。

編集: 迅速な対応に感謝します。TASが言及したように、いくつかのテンプレートを含め、自分をに変更して、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;
}
4

3 に答える 3

2

いくつかの解決策があります。最も適していると思われるのはBoost.Variantです。Lineあなたが示したようにあなたとCircleクラスを定義してからGeometricData、のtypedefを作成するvariant<Line, Circle>と、どちらかのインスタンスをそこに格納できます。GeometricDataから格納されている実際のオブジェクトに戻りたい場合は、キャストを実行するか、いわゆるビジターを記述できます。ビジターは、可能なタイプごとにアクションを指定する単なるクラスであり、boost::apply_visitor保存されているものに基づいて適切なアクションを選択するために使用できます。

例 (より簡単な表記のためにベクトルを使用):

struct Line {
    Vector3d startPoint, endPoint;
};

struct Circle {
    Vector3d center;
    float radius;
};

using GeometricData = boost::variant<Line, Circle>;

struct MidpointVisitor : boost::static_visitor<Vector3d> const {
    Vector3d operator()(Line const& line) {
        return (line.startPoint + line.endPoint)/2;
    }

    Vector3d operator()(Circle const& circle) const {
        return circle.center;
    }
};

void foo() {
    GeometricData data;
    // ...
    auto midpoint = boost::apply_visitor(MidpointVisitor{}, data);
    // ...
}

型の厳密性が低いソリューションはBoost.Anyですが、この場合の利点はありません。別のオプションが必要だったとしても、おそらくそれを明示的に指定したいと思うでしょう。

void*スマート ポインターを使用して (または共通の基本クラスと RTTI を使用して)ソリューションを機能させることができるのではないかと思います。ただし、私が確認できる唯一の利点は、コンパイルが高速で、ひどいコンパイラ エラー メッセージが少なくなることです。一方、動的割り当てに煩わされ、ビジターを持つことはできません。

また、Variant の方針に沿って何かを効果的に実装して、独自のユニオンを作成することもできます。それには、構築、破壊、および配置がすべて正しいことを確認し、未定義の動作のあいまいなケースを引き起こさないようにする必要があります。それが問題ではなく、本当にライブラリを使用したくない場合は、オプションですが、非常に車輪の再発明です。

于 2013-10-20T18:21:56.490 に答える
1

おそらく共有インターフェースが次のように見えるポリモーフィズムと言えます。

class Edge
{
    enum EdgeType
    {
        CIRCLE,
        LINE
    };

    EdgeType GetType();
}

次に、どこかの switch ステートメントで、次のようなことができます。

switch (myEdge.GetType())
{
    case Edge::EdgeType::CIRCLE:
        auto myCircle = (Circle)myEdge;
        // do things specific to circle
        break;
    case Edge::EdgeType::LINE:
        auto myLine = (Line)myEdge;
        // do things specific to line
        break;
}

そうは言っても、switch ステートメントで可能な限りポリモーフィズムを使用しようとしますが、上記のインターフェイスを使用すると、エッジを使用する関数に、型に基づいてさまざまなことを行うためのロジックを含めることができます。

于 2013-10-20T18:39:46.203 に答える