Warum unterstützt C keine Template-Kovarianz und wie können wir die daraus resultierenden Typsicherheitsprobleme bei der Arbeit mit polymorphen Templates beheben?

Vorlagen und Polymorphismus in C

Betrachten Sie die folgende Klassenstruktur:

<code class="cpp">class Interface {
  // ...
};

class Foo : public Interface {
  // ...
};

template <class t>
class Container {
  // ...
};</class></code>

Ein Konstruktor einer anderen Klasse Bar ist wie folgt definiert:

<code class="cpp">Bar(const Container<interface>& bar) {
  // ...
}</interface></code>

Beim Versuch, den Konstruktor jedoch wie folgt aufzurufen:

<code class="cpp">Container<foo> container();

Bar *temp = new Bar(container);</foo></code>

wir stoßen wir auf den Fehler „Keine passende Funktion“.

Polymorphismus in Vorlagen

Das Konzept des Polymorphismus in Vorlagen oder der Vorlagenkovarianz würde bedeuten, dass, wenn Klasse B von Klasse A erbt, T erbt ebenfalls von T. Dies ist jedoch in C oder anderen Sprachen wie Java oder C# nicht der Fall.

Grund für fehlende Template-Kovarianz

Das Fehlen von Template-Kovarianz wird durch die gerechtfertigt Typsicherheit muss gewahrt bleiben. Betrachten Sie das folgende Beispiel:

<code class="cpp">// Class hierarchy
class Fruit {...};
class Apple : public Fruit {...};
class Orange : public Fruit {...};

// Template instantiation using std::vector
int main() {
  std::vector<apple> apple_vec;
  apple_vec.push_back(Apple()); // Valid

  // With covariance, the following would be allowed
  std::vector<fruit>& fruit_vec = apple_vec;

  // Adding an Orange to the vector
  fruit_vec.push_back(Orange());

  // Incorrect addition of an orange to an apple vector
}</fruit></apple></code>

Dies zeigt das Potenzial für unsicheres Verhalten, wenn Vorlagen kovariant wären. Daher ist T und T werden als völlig unterschiedliche Typen betrachtet, unabhängig von der Beziehung zwischen A und B.

Lösung des Problems

Ein Ansatz zur Lösung des Problems in Java und C# ist die Verwendung von Bounded Platzhalter bzw. Einschränkungen:

<code class="java">Bar(Container extends Interface) {...}</code>

<code class="csharp">Bar<t>(Container<t> container) where T : Interface {...}</t></t></code>

In C kann die Boost Concept Check-Bibliothek ähnliche Funktionen bereitstellen. Die Verwendung einer einfachen statischen Zusicherung kann jedoch eine praktischere Lösung für das spezifische Problem sein:

<code class="cpp">static_assert(std::is_base_of<interface foo>::value, "Container must hold objects of type Interface or its derived classes.");</interface></code>

Das obige ist der detaillierte Inhalt vonWarum unterstützt C keine Template-Kovarianz und wie können wir die daraus resultierenden Typsicherheitsprobleme bei der Arbeit mit polymorphen Templates beheben?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!