template <typename T, int m, int n>
class basic_matrix
  : //... (boost operators)
{
  //...
  boost::array<T, m*n> data; //hier könnte ich auch ein zweidimensionales Array nehmen, aber ob das schneller ist...
  public:
  //allerlei operatoren und methoden
};

So weit so gut. Jetzt gibt es aber für quadratische Matritzen einige spezielle Operationen, die ich implementieren will, invertieren, Determinant berechnen, Transponieren etc. Außerdem will ich für Matritzen der Größen 4*4, 3*3 und 2*2 noch ein paar etwas schnellere Varianten dieser Operationen implementieren. Das schreit natürlich nach Templatespezialisierung, und die ist im Grunde auch garkein Problem. Aber wenn ich jetzt z.B. basic_matrix<T, 3, 3> spezialisiere, dann muss ich ALLE anderen Operationen wie Addieren, Subtrahieren usw. alle neu reinschreiben. Da dachte ich mir, na dann leite ich einfach von basic_matrix ab und überlade alle Operationen, die sich ändern. Aber das geht nicht, denn

template <typename T>
class basic_matrix<T, 3, 3>
  :basic_matrix<T, 3, 3>
{
  T determinant();
  //...
};

gibt verständlicherweise einen Fehler wegen unendlicher Rekusion. Im Internet habe ich nur allgemeine Infos über Templatespezialisierung gefunden, nichts, was meinem Problem ähnlich ist. Aber irgendwie kann ich nicht glauben, dass das ein Einzelfall ist.
geloescht

template <typename T, int m, int n>
class basic_matrix_base
// ...
};

template <typename T, int m, int n>
class basic_matrix
  : public basic_matrix_base<T, m, n>
//...  nur ctors und ggf. zuweisung
};

template <typename T>
class basic_matrix<T, 3, 3>
  :basic_matrix_base<T, 3, 3>
//...
};

usw.

ah, danke, darauf bin ich nicht gekommen. Wird zwar etwas mehr Code, aber sehr viel weniger als wenn ich wirklich alles doppelt und dreifach schreiben würde.
Dann hab ich noch ne Frage, ich hab irgendwo in der Boost-Doku, genauergesagt hier http://boost.org/libs/utility/operators.htm#chaining (ich hab mit boost gerade erst angefangen aber es erleichtert doch einiges) gelesen, dass bei manchen Compilern bei Ableitung von Klassen ohne Member die Objektgröße anwächst. Da auch mal große Mengen an Matrizen und Vektoren gespeichert werden sollen wäre das nicht sehr schön. Ist das wirklich so?

Wenn nicht, stände diese Behauptung dort nicht. Sobald Mehrfachvererbung im Spiel ist, ist diese Objektvergrößerung mitunter erforderlich, weil zwei verschiedene (Sub-)objekte nicht die gleiche Adresse haben können. Für die gewöhnliche einfache Vererbung wird das aber wohl kein Problem sein, wenn dein Compiler nicht von vorgestern ist.

template <typename T, int m, int n>
  class basic_matrix
    :public basic_matrix_base<T, m, n>
  {
    public:
    explicit basic_matrix(type);
  };

Das ist im Moment meine kleine Ableitung. type ist in basic_matrix_base definiert:

//...
    public:
    enum type
    {
      null,
      identity
    };
    //...

Eigentlich sehe ich nicht, was da falsch sein soll, ich kriege aber folgendes:

matrix.hpp:89: Fehler: nur Deklarationen von Konstruktoren können »explicit« sein

Und wenn ich statt "explicit basic_matrix(type)" "explicit basic_matrix(basic_matrix_base<T, m, n>::type);" schreibe noch seltsamer:

matrix.hpp:89: Fehler: Typ »rayce::basic_matrix_base<T, m, n>« ist nicht vom Typ »rayce::basic_matrix<T, m, n>« abgeleitet

Ich verstehe kein Wort von diesen Fehlermeldung und habe auch schon alles nach fehlenden ; oder Klammern durchsucht, aber nichts gefunden...

template <typename T, int m, int n>
  class basic_matrix
    :public basic_matrix_base<T, m, n>
  {
    public:
    explicit basic_matrix(typename basic_matrix_base<T, m, n>::type);
  };

oder

template <typename T, int m, int n>
  class basic_matrix
    :public basic_matrix_base<T, m, n>
  {
    public:
    typedef typename basic_matrix_base<T, m, n>::type type; // die enumkonstanten sind damit noch nicht bekannt
    explicit basic_matrix(type);
  };

oder (oder auch nicht, hab das noch nie mit typen und using versucht)

template <typename T, int m, int n>
  class basic_matrix
    :public basic_matrix_base<T, m, n>
  {
    public:
    using basic_matrix_base<T, m, n>::type;
    explicit basic_matrix(typename type);
  };

PS: matrix.hpp:108: Fehler: es gibt keine Argumente für »get_data«, die von einem Templateparameter abhängen, weshalb eine Deklaration von »get_data« verfügbar sein muss

template<typename T, int m, int n, bool = (m==3&&n==3) /*hier alle Fälle, die erweitert werden sollen geeignet einschließen)*/>
class basic_matrix; // wird nicht definiert

// erste Spezialisierung, die Grundform:
template<typename T, int m, int n>
class basic_matrix<T, m, n, false>
// ...

// Spezialisierung für 3x3
template<typename T>
class basic_matrix<T, 3, 3, true>
    : public basic_matrix<T, 3, 3, false>
// ...

Ist systematisch ein bisschen unsauber, spart aber wohl ein wenig code

Zu überlegen wäre auch noch, ob eine Spezialisierung des Templates überhaupt erforderlich ist. Du kannst ja erstens auch dem Primärtemplate zusätzliche Funktionen spendieren, deren Definitionen für nicht passende Templateargumente nicht instantiierbar sind (oder per SFINAE herausfallen) oder du spezialisiert einzelne Funktionen. Das ist aber auf explizite Spezialisierung beschränkt. Die Beschränkung könnte z.B. dadurch umgangen werden, das diese Funktionen selbst einen Funktor aufrufen, diesen wiederum könntest du auch wieder partiell (also für alle T) spezialisieren.

Aber die selben Methoden für m==n==3 und m==n==2 müssen ja auch definiert werden und da liegt der Hund begraben.

Das geht doch ebenso einfach:

template<typename T, int n>
class basic_matrix<T, n, n, true>
// ...

so hast du zwar auch ein template wenn m,n nicht 2 oder 3 ist, aber dieses wird ja dank des bools im Regelfall nicht instantiiert.

Ja, und eben in der Klasse, der sie angehören.

Dann ist das Problem weitaus einfacher zu lösen, als du anfangs dargestellt hast.
per SFINAE:

template<typename T, int m, int n>
class basic_matrix
{
public:
//    void foo(); wird zu
    typename enable_if_c<m!=m||m!=2&&m!=3,void>::type foo(); // der allgemeine Fall
    typename enable_if_c<m==n&&m==2,void>::type foo(); // m,n == 2
    typename enable_if_c<m==n&&m==3,void>::type foo(); // m,n == 3
// usw.
};

Es gibt noch ein paar andere Möglichkeiten, das mittes enable_if zu machen , ich verweise dazu auf die Boost Doku

Eine andere Möglichkeit:

template<typename T, int m, int n>
class basic_matrix
{
private:
    template<typename U=T,int o=m,intp=n> friend class DoFoo;
public:
    void foo() { DoFoo<>()(this); }
};

template<typename T, int m, int n> class basic_matrix::
template<typename U, int o, int p> class DoFoo
{
    void operator()(basic_matrix<T,m,n>*) { /* ... */ }
};

template<typename T, int m, int n> class basic_matrix::
template<> class DoFoo<T,2,2>
// usw.

Indirektion löst noch (fast) jedes Problem.

Hier mal ein Beispiel von: http://www.lrz-muenchen.de/~ebner/C++/Slides/cxxkurs.html

// Klassendeklaration:
template<bool C>
class IfThen { };

// Spezialisierung für beide Fälle
class IfThen<true> {
  public:
    static inline void f()
    { statement1; }
};

class IfThen<false> {
  public:
    static inline void f()
    { statement2; }
};

// Ersatz des 'if/else'-Statements:
IfThen<condition>::f();

Gruß Baracke