Implementieren einer einzelnen Klasse mit anderen Argumenten

Question

Ich arbeite an einem Datenparser für ein Projekt. Ich muß eine Datei analysieren, die zwei verschiedene Arten von Objekten enthalten:

Typ-1: sb0 hardrectilinear 4 (0, 0) (0, 82) (199, 82) (199, 0)

Type-1 muss als Klassenblock mit den folgenden Attributen gespeichert werden: BlockID, BlockType, Anzahl_der_Kanten, untere linke, untere rechte, obere linke, obere rechte Ecke.

Typ-2: SB1 softrectangular 24045 0,300 3,000

Typ-2 auch als Klassenblock gespeichert werden muss, mit den folgenden Attributen: BLOCKID, Blocktype, Fläche, min_aspectRatio, max_aspectRatio.

Ist es möglich, eine einzelne Klasse namens "block" mit einem anderen Satz von Argumenten abhängig vom Attribut "BlockType" zu erstellen? Ich habe einen Parser gebaut, aber ich benutzte zwei verschiedene Klassen für jeden BlockType mit sstream.

Ich habe meine Implementierung des Parsers gezeigt, wenn die zu analysierende Textdatei nur Typ-2 enthält. Irgendwelche Ideen, wie ich das mit einer einzigen Klasse machen kann?

SoftBlock.h:

#ifndef SOFTBLOCKLIST_H_ 
#define SOFTBLOCKLIST_H_ 
#include <string> 
#include <vector> 
#include "SoftBlock.h" 
#include <fstream> 


class SoftBlockList { 
public: 
    SoftBlockList(std::string input_file); 

    std::vector<SoftBlock> get_softblocklist(); 

private: 
    std::vector<SoftBlock> softblocklist; 

}; 

#endif /* SOFTBLOCKLIST_H_ */ 

SoftBlock.cpp: 

#include "SoftBlockList.h" 
using namespace std; 

SoftBlockList::SoftBlockList(string input_file) { 
    ifstream filehandle; 
    filehandle.open(input_file.c_str()); 
    string temp; 
    while(filehandle.good()){ 
     getline(filehandle, temp); 
     SoftBlock block(temp); 
     softblocklist.push_back(block); 
    } 
    filehandle.close(); 
} 

vector<SoftBlock> SoftBlockList::get_softblocklist(){return 
softblocklist;} 

Answer 1

Ein einfacher Weg, dies zu tun wäre, um eine Vereinigung zu verwenden. Die Union kann immer nur 1 aktives Mitglied haben und belegt nur eine Größe, die dem größten Mitglied entspricht.

#include <iostream> 
using namespace std; 

class Block { 
    public: 
    struct Type1 { 
     int number_of_edges; 
     float lowerleft, lowerright, upperleft, upperright; 
    }; 
    struct Type2 { 
     double area; 
     float min_aspectRatio, max_aspectRatio; 
    }; 

    union combinedData { 
     Type1 t1; 
     Type2 t2; 
    }; 

    int BlockID; 
    int BlockType; 

    combinedData data; 
}; 

int main() { 
    Block block; 
    block.BlockType = 1; 
    block.data.t1.number_of_edges = 1; // Type1 is now active 
    cout << block.data.t1.number_of_edges << endl; 
    block.BlockType = 2; 
    block.data.t2.area = 1.5678; // Switched to Type2 being the active member 
    cout << block.data.t2.area << endl; 
} 

Sie können dann den Wert von BlockType verwenden, um festzustellen, welches Mitglied aktiv ist.