C ++ Schabloun vs Ierfschaft

Ech mierke just wéi schwéier Froen ze sinn ... Hoffentlech kann ech Beispiller ginn déi si béid, genuch präzis fir mäi Problem ze demonstréieren a kuerz genuch fir net alles duercherneen ze bréngen ... Op d'mannst ass et d'Méiglechkeet fir z'änneren.

Also dat ass eng Aart vu menger Situatioun de Moment. Natierlech hunn ech et e bësse geännert wat Logik / Struktur ugeet (a wat d'Nimm souwisou ugeet) probéiert op d'Essenz vu menger Fro ze fokusséieren:

// MyClass deals with lists (actually several data structures) of the
// type MyType which should support different types and has to be 
// efficiently dealt with. Templating seems just right here
class MyClass
{
  ...

  void doSomething<class MyType>(vector<MyType> someList);

  ...

  // At some point I have to extract elements of the type MyType.
  // The extractor obviously depends on MyType but it is not possible to
  // Create a general version that could use templates itself 
  // (unless I use a specialization for each possible MyType)

  // I am stuck between these two alternatives:

  // Possibility1:
  // Let the client pass the right extractor and template it.
  template<class Extractor, class MyType>
  void extract(const Extractor& extractor, const string& source, 
               vector<MyType>* dest)
  {
     extractor.extract(source, dest);
  }

  // Possibility2:
  // Use a member _extractor of some base type that has to be set
  // to a specialization. The ExtractorBase has a virtual method
  // template<T> void extract(const string& source, vector<T>* myType) = 0
  // with no definition that is only defined in subclasses wrt certain
  // postings.
  ExtractorBase _extractor;

  template<class MyType>
  void extract(const string& source, vector<MyType>* dest)
  {
     _extractor.extract(source, dest);
  }
}

De Moment hätt ech d'Méiglechkeet léiwer1, well ech muss mech net mess mat Ierfschaft am Extractor fir all Varianten vu MyType an assoziéierten Extractor wëll ech an Zukunft probéieren.

Op der anerer Säit kënnen Extraiteren komplexe Code a verschidde Memberen erfuerderen (sou eppes wéi rieseg Kaarten déi gewësse Inputen op bestëmmte Wäerter maarten) . Also gëtt et kee Performance Gewënn mat Templates. Besonnesch mat Header-Datei nëmmen Extractoren a méiglecherweis och Funktoren déi ugeluecht solle ginn, sinn iergendwéi net a Fro. An der Vergaangenheet war dëst e staarken Zeigefanger fir mech datt Templatéiere just d'Kodekomplexitéit erhéicht (mat Instanatioun ze kämpfen, d'Liewe fir de Clientcode méi schwéier ze maachen, asw.) An datt ech sollt probéieren et ganz ze vermeiden.

Oder ass et eng drëtt Méiglechkeet un déi ech guer net geduecht hunn?