Der nachfolgende Code lässt sich nicht linken.

Erklärung

Ich versuche eine Klasse a_c zu bauen, die Daten verwaltet (noch leer), welche anschliessend von zwei Instanzen der Klassentemplates a_func_c benutzt werden. Während die Funktionen von a_c alle inline in a.h stehen, sollen die Funktionsdefinitionen der Members von a_func_c in a.cpp definiert sein (wichtig).

Denkfehler?

Ich gehe davon aus, dass mit der Definition von a in main() auch gleich die beiden Klassentemplates w und b als Membervariable der Klasse a_c angelegt werden. Wo ist mein Fehler?

main.cpp

#include <stdio.h>
#include "a.h"

int main()
{
  a_c a;

  printf_s("%d\n", a.foo(0));

  return 0;
}

a.h

#ifndef A_H
#define A_H

template<int M, int Y>
class a_func_c {
  friend class a_c;

private:
  int foo() const;
};

class a_c {
private:
  a_func_c<0, 1> w;
  a_func_c<1, 0> b;

public:
  int foo(int stm) const;
};

inline int a_c::foo(int stm) const {
  return (stm == 0) ? w.foo() : b.foo();
}

#endif

a.cpp

#include "a.h"

template<int M, int Y>
int a_func_c<M, Y>::foo() const {
  return 2*M + 4*Y;
}

Alles in die >Headerdatei schreiben. Im aktuellen C++ Standard nicht anders möglich.

Es gibt noch eine Lösung via Metaprogrammierung mit Präprozessor. Gefällt mir aber nicht.

Gibt es überhaupt keine Möglichkeit über Dateigrenzen (ohne in der Header zu definieren) Templates zu bauen?

Tatsächlich? Heisst das, dass ich die Sourcedatei am Ende der Header includieren muss?

Ja, aber keine .cpp-Datei, denn die wird kompiliert. Nimm .inl, .ipp, .impl, .h oder .hpp.

Tomahawk schrieb:

Es gibt noch eine Lösung via Metaprogrammierung mit Präprozessor. Gefällt mir aber nicht.

Hier kommst du aber auch nicht drum herum, alles in den Header zu schreiben.

Janjan schrieb:

Nicht im aktuellen C++ Standard. Im neuen, C++0x (x ist eine HexZiffer ;)) Standard wird es möglich sein.

Bist du sicher? Auf welches Feature spielst du an?

Janjan schrieb:

Nicht im aktuellen C++ Standard. Im neuen, C++0x (x ist eine HexZiffer ;)) Standard wird es möglich sein.

Bist du sicher? Auf welches Feature spielst du an?

Sicherlich auf das

export template

Siehe folgenden Link:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39467.html

Dann halt alles innerhalb derselben Sources implementieren und externe Schnittstellen bauen.

Im aktuellen C++ Standard nicht anders möglich.

Im Standard schon, der definiert das Keyword export. Das wird allerdings von fast keinem Compiler uterstützt. -> "Mit aktuellen C++ Compilern nicht anders möglich"

In einer Schachengine namens RobboLito kommt eine Metaprogrammierung mittels Präprozessor zum Einsatz, um nicht alle Funktionen manuell duplizieren zu müssen (wegen Weiss und Schwarz).

Ist ein typisches Problem, und hier kann man die gespiegelten Duplikate der Funktionen vom Präprozessor über die Dateigrenzen "ersetzen" lassen. Natürlich lassen sich - wie auch bei den Funktionstemplates - keine Funktionen mit externer Bindung mehr nutzen.

Duplizierung für Schwarz und Weiss a.cpp

int white_foo();
int black_foo();

#define my_foo black_foo

int my_foo() {
  // der eigentliche Algorithmus...
}

#undef my_foo

#define my_foo white_foo

int my_foo() {
  // der eigentliche Algorithmus...
}

Oder etwas eleganter, damit der Code tatsächlich vom Präprozessor dupliziert wird

// a_func.h

int white_foo();
int black_foo();

// a.cpp

#ifndef A_H
#define A_H

#include "a_func.h"
#include "a.cpp" // "rekursives" includieren
#include "white.h"

#else

#include "black.h"

#endif

int my_foo() {
  // der eigentliche Algorithmus...
}

// white.h

#undef my_foo
#define my_foo white_foo

// black.h

#define my_foo black_foo

Was ist der "bessere" Ansatz zum Duplizieren von Funktionen - der Präprozessor oder die Templates?

Ich habe zu wenig Ahnung, um das a priori einschätzen zu können

und wieso möchtest du das nutzen?

Für die Entwicklung eines Rechenalgorithmus, in dem ich viele Funktionen duplizieren muss und zwar über die Dateigrenzen hinweg. Deswegen bin ich mit dem Templatemechanismus erstmal in der Sackgasse steckengeblieben, da mit das Problem mit dem C++ Standard (export template wird nicht unterstützt) nicht klar war.

Manuellen Duplizieren von Code ist blödsinnig, da zu viel Pflegeaufwand und fehleranfällig. Und wegen der Performance muss ich möglichst überall "parametrisieren".

bb

Sicherlich auf das

export template

Siehe folgenden Link:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39467.html

Das macht keinen Sinn. Nicht nur, dass export schon heute kaum einsetzbar ist, sondern auch, dass es in C++0x offiziell aus dem Standard entfernt wird.** export wird nicht mehr Bestandteil von C++ sein** – höchstens noch als reserviertes Schlüsselwort ohne Bedeutung. Und das ist gut so.

Lies vielleicht auch Why We Can't Efford Export, dort erfährst du mehr über die Hintergründe.

Tomahawk schrieb:

Was ist der "bessere" Ansatz zum Duplizieren von Funktionen - der Präprozessor oder die Templates?

Ich habe zu wenig Ahnung, um das a priori einschätzen zu können

Von den Möglichkeiten, Templates direkt zu nutzen oder sie mittels Präprozessor nachzubauen, halte ich die erste für die weitaus klügere. Wie bereits erwähnt hilft dir der Präprozessor nicht dabei, von Headerdefinitionen abzukehren. Im Gegenzug bringt er aber einige Probleme, die von Templates gelöst werden. Was nicht heisst, dass Makros nie angebracht wären, aber hier sind sie es definitiv nicht.