Ist es richtig, sich Vorlagen als nichts anderes vorzustellen, als dass der Compiler eine Textersetzung durchführt und v ⇐ C++

[Anonymous]

Ich habe Vorlagen immer als etwas geheimnisvoll empfunden. Ich denke, das liegt daran, dass ich nie groß darüber nachgedacht habe, was der Compiler tatsächlich mit ihnen macht. Kürzlich kam mir jedoch ein Gedanke und ich kam zu dem Schluss, dass sie wahrscheinlich eigentlich sehr einfach sind. Ich möchte wissen, ob das mentale Modell, das ich habe, der richtige Weg ist, darüber nachzudenken.
Meine Schlussfolgerung ist, dass der Compiler, wenn er eine Vorlage sieht, im Quellcode praktisch eine Zeichenfolgenersetzung durchführt, bevor er versucht, das Ergebnis zu kompilieren.
Dies kann anhand eines Beispiels veranschaulicht werden.

Code: Select all

struct StringableThing1 {
std::string to_string() { return std::string("hello world"); }
};

struct StringableThing2 {
std::string name;
std::string to_string() { return name; }
};

struct NotAStringableThing {
std::vector data;
std::vector to_binary_string() { return data; }
};

template
void do_something(Stringable something) {
std::string some_string = something.to_string();
std::println(some_string);
}

// works
StringableThing1 thing1;
do_something(thing1);

// works
StringableThing2 thing2;
do_something(thing2);

// does not work
NotAStringableThing thing3;
do_something(thing3);

Im obigen Beispiel ist do_something eine Vorlagenfunktion. Der Vorlagenparameter ist Stringable. Der Code dieser Funktion stellt eine implizite Anforderung dar. Diese Anforderung besteht darin, dass der folgende Code für jedes als Vorlagenparameter übergebene Stringable kompiliert werden muss.

Code: Select all

Stringable stringable;
std::string tmp = stringable.to_string();

Mit anderen Worten, jedes Stringable muss eine Funktion to_string haben, die aufgerufen werden kann. Diese Funktion akzeptiert keine Argumente und gibt einen std::string zurück.
Das Beispiel kann weiter erweitert werden und wird möglicherweise klarer, indem eine weitere Funktion eingeführt wird, die für keine der drei Beispielstrukturen kompiliert wird.

Code: Select all

// note same template parameter name chosen deliberately here -
// not the same `Stringable` as before

template
void do_something(Stringable something) {
std::string some_string = something.to_string();
std::println(some_string);
std::vector some_binary_string = something.to_binary_string();
std::println(binary_string_to_utf8(some_binary_string));
}

In diesem Fall funktioniert keiner der drei Typen. Die ersten beiden Zeilen dieser Funktion werden mit den ersten beiden Strukturen kompiliert, die letzten beiden Zeilen jedoch nicht. Andererseits werden die letzten beiden Zeilen dieser Funktion mit struct NotAStringableThing kompiliert, die ersten beiden Zeilen jedoch nicht.
Ist das alles? Wenn ja, scheinen Vorlagen eigentlich sehr einfach zu sein. Ich weiß nicht, warum ich angenommen habe, dass sie viel komplizierter sein müssen.