C++ std::map-template-Klasse Werte

Versuche ich zu erklären, eine Row und ein Column Klasse, mit der Row mit einem privaten std::map mit Werten Hinweis auf eine vorgefertigte Column. So etwas wie dieses:

template <typename T>
class DataType {
  private:
    T type;
};
template <typename T>
class Field {
  private:
    T value;
    DataType<T> value;
};
class Row {
  private:
    std::map<unsigned long,Field*> column;
};

Naja, ich denke, im Prinzip ist die Row Klasse sollte nicht wissen, welche Art von Field (oder Column) wir verwenden möchten, d.h. ob es ein Field<int> in Spalte 1 oder eine Field<double> in Spalte 2. Aber ich bin mir nicht sicher, was die korrekte syntax für die Row::column Erklärung, oder wenn die std::map in diesem begrenzten Sinn, und ich sollte über etwas anderes.

Ich appretiate Sie Anregungen und danke Ihnen im Voraus.

InformationsquelleAutor der Frage jbatista | 2009-02-20

c++methods stdmap templates

23

Field allein ist kein Typ, sondern eine Vorlage generieren kann eine Familie von Typen, wie Field<int> und Field<double>. Alle diese Felder sind nicht miteinander verwandt, so dass Sie die eine ist irgendwie abgeleitet von der anderen oder so. So müssen Sie zum herstellen einen Bezug zwischen diesen generierten Typen an. Eine Möglichkeit ist die Verwendung einer gemeinsamen nicht-template-Basisklasse:
```
class FieldBase { };

template <typename T>
class Field : public FieldBase {
  private:
    T value;
    DataType<T> type;
};
class Row {
  private:
    std::map<unsigned long,FieldBase*> column;
}; 
```
Und betrachten Sie die Verwendung von smart-pointer statt, die raw-Zeiger in den code. Anyway, das problem ist jetzt, dass die Typ-Informationen verloren gehen - egal, ob Sie zu einem Punkt Field<double> oder eine Field<int> ist nicht mehr bekannt und kann nur erkannt werden, indem Sie einige Sortieren von Typ-flag in die base, welche festgelegt ist durch die Vorlagen abgeleiteten Klasse oder von Fragen, RTTI mit
```
dynamic_cast<Field<int>*>(field) != 0
```
Aber das ist hässlich. Vor allem, weil das, was Sie wollen, gibt es einen semantischen Wert. I. e Sie möchten, um der Lage sein, kopieren Sie die Zeilen, und es würde kopieren Sie alle it-Bereiche. Und Sie möchten, um eine doppelte, wenn ein doppelt gespeichert ist - ohne zuerst mit RTTI-hack Ihren Weg zu den abgeleiteten Typ.

Einen Weg, es zu tun, ist die Verwendung einer besonderen union. Das ist im Grunde eine union für einige beliebige Typen und zusätzlich ein Typ-flag, das speichert, was Wert ist aktuell gespeicherte Feld (e -.g, ob ein double, int, ...). Zum Beispiel:
```
template <typename T>
class Field {
  private:
    T value;
    DataType<T> type;
};
class Row {
  private:
    std::map<unsigned long, 
             boost::variant< Field<int>, Field<double> > > 
      column;
};
```
boost::variant macht die ganze Arbeit für Sie. Sie können visitation zu machen, nennen einen Funktor mit der rechten überlastung. Haben Sie einen Blick auf seine Handbuch

InformationsquelleAutor der Antwort Johannes Schaub - litb
1
1. Sie bekam eine Fehlermeldung, die es gibt: Sie haben an "Wert" Mitglied in Feld (man sollte wahrscheinlich "Typ").
2. Bitte halten Sie nicht raw-Pointer in der map-Wert. Verwenden boost::shared_ptr.
3. Auch, Sie sollte einen guten Grund haben für das schreiben solcher Klassen, in denen gibt es viele DB - /Tabellen-handling-code, die es schon gibt, das können Sie wahrscheinlich verwenden. Also, wenn es zutrifft, verwenden Sie so etwas vorhandenes und nicht schreiben Sie Ihre eigenen Tisch-handling-code.
Nun, um Ihre Frage zu beantworten :), Feld<> Klassen Erben von einer gemeinsamen Basisklasse, die von allen Datentypen. Diese Möglichkeit, einen container wie Ihre Spalte anzeigen kann, halten Zeiger (das gemeinsamen Zeiger) auf abgeleitete Objekte, die Instanzen der template-Klasse.

InformationsquelleAutor der Antwort Assaf Lavie
0

Einen Row< int, float, int> ist wirklich anders, eine Row<int, std::string>.
Klar, Row<int,float,int>.field<0> sollte ein Field<int> während Row<int,float,int>.field<1> sollte ein Field<float>. Und Row<int,float,int>.field<3> ist ein compiler-Fehler.

Der einfachste Weg, dies zu tun ist mit Boost. Eine ganze Menge von der Intelligenz wurde erstmals von Loki (siehe Modern C++ Designvon Andrei Alexandrescu) aber Steigern ist moderner und besser unterstützt.

Normalerweise würden Sie nicht die Iteration über die Felder - jedes Feld hat seinen eigenen Typ. Aber Sie tun, Sie würde wirklich brauchen eine FieldBase. Wenn Sie brauchen, eine solche Schnittstelle, ist es wahrscheinlich lohnt zu speichern die Felder intern als boost::array<FieldBase, N> (d.h. Row<int,float,int> hat eine boost::array<FieldBase, 3>). Sie sollten nie müssen dynamic_cast dass FieldBase*obwohl. Das ist ein Laufzeit-test, und Sie immer wissen, die genaue T jeder Field<T> zur compile-Zeit.

InformationsquelleAutor der Antwort MSalters

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.