Ich hätte gerne eine Variable Parameterliste,
dessen Anzahl von einem Templateparameter abhängt.
Etwa:

template <typename T1,size_t Dimension>
class leaf{

public:
    leaf(size_t _d=Dimension,...);

private:
    size_t _D;

};

Es soll aber so sein, dass der Benutzer der Templateklasse beim Templateinstanzieren die Dimension mitgeben soll, aber dann beim wirklichen Konstruktoraufruf, lediglich so viele Aurgumente übergeben soll, wie er dann auch als Dimension übergeben hat.
Z.B.:

/// Benutzen von leaf temp. instanz
leaf< double, 3> _leaf = new leaf(0.0,0.1,0.2);
leaf< double, 1> _leaf = new leaf(0.0);
leaf< double, 4> _leaf = new leaf(0.0,0.0,0.1,0.2);

/// Aber nicht
leaf< double, 2> _leaf = new leaf(2,1.0,0.0);

P.s.: ich bin mir daüber im klaren, dass es für das Problem andere Lösungen gibt. Die kenne ich aber schon. Ich interessiere mich tatsächlich ausschließlich für die Lösung.... =)...

okay, hat sich erledigt...

Ich hoffe deshalb, weil du eingesehen hast, dass dies mehr als gefährlich ist !!!

Aber das kann man als Programmierer eigentlich immer...

Da meine Klasse eine Template Instanz ist, und die Anzahl der Parameter durch einen Template Parameter festgelegt ist , ist die größe des maximal auslesbaren Speicherbereichs jedoch durch den Programmierer eindeutig festegelegt, und kann nicht zur Laufzeit bestimmt werden...

Also ich fände es akzeptabel.
Schlilmm fände ich, wenn der Programm Benutzer die Anzahl der Parameter angeben könnte....

Passt ???

Und warum sowas Merkwürdiges wie

leaf<double, 3> _leaf = new leaf(0.0, 0.1, 0.2);

statt

leaf<double, 3> _leaf(0.0, 0.1, 0.2);

?

leaf<double,3>(1.2,3,3.4)

packt einen int auf den Stack. Und keiner merkt es.

leaf< double, 3> *_leaf = new leaf(0.0,0.1,0.2);
leaf< double, 1> *_leaf = new leaf(0.0);
leaf< double, 4> *_leaf = new leaf(0.0,0.0,0.1,0.2);

/// oder wie du meintest
leaf< double, 3> _leaf(0.0,0.1,0.2);
leaf< double, 1> _leaf(0.0);
leaf< double, 4> _leaf(0.0,0.0,0.1,0.2);

Das mit der Typ-kontrolle habe ich nicht gesehen.... ja das ist ein Argument...
Das macht es nicht gerade schön...
Werd mir mal die Variadic Templates anschauen...

template <typename T, unsigned int N>
struct Array;

template <typename T>
struct Array<T, 1>
{
	explicit Array(const T& arg1);
};

template <typename T>
struct Array<T, 2>
{
	explicit Array(const T& arg1, const T& arg2);
};

Die Umsetzung ist unschön in C++98, aber du willst es ja unbedingt genau so

Die Implementierung kannst du in eine separate Klasse auslagern. Für Codegenerierung könntest du den Präprozessor verwenden, für fortgeschrittene Anwendungen kann dir Boost.Preprocessor behilflich sein.

Hoffe ich bekomme das mit den Variadic Templates hin...
Wobei ich da noch nciht so ganz angebkommen bin muss ich sagen...