Antwoord.

Sjablonen met standaardparameters zijn een krachtig mechanisme voor generiek programmeren in C++.

Achtergrond:

De STL-bibliotheek begon met sjablonen. Later werd de mogelijkheid geïntroduceerd om standaardwaarden voor parameters op te geven voor zowel sjabloonfuncties als klassen, om sjablonen universeler te maken en de uitbreidbaarheid van de code te ondersteunen.

Probleem:

Niet-voor-de-hand-liggende conflicten zijn mogelijk wanneer er overloads van reguliere en sjabloonfuncties bestaan, evenals ambiguïteiten bij specialisaties. Standaardparameters in sjablonen kunnen de flexibiliteit verhogen, maar leiden vaak tot verwarrende compilatiefouten.

Oplossing:

Het is beter om het aantal standaardwaarden in sjablonen te minimaliseren, vooral als er overlap is met niet-sjabloonversies. Bij het aanroepen van functies heeft een exacte overeenkomst met een reguliere functie prioriteit boven een sjabloon.

Voorbeeldcode:

template<typename T = int>
T multiply(T a, T b = T(2)) {
    return a * b;
}
int multiply(int a, int b) {
    return a + b;
}

De aanroep multiply(5, 4) kiest de functie int multiply(int, int), terwijl de aanroep multiply<>(5) de sjabloon aanroept, en b de waarde 2 aanneemt.

Belangrijke kenmerken:

Standaardwaarden worden alleen in de eerste verklaring/bepaling van het sjabloon gedeclareerd.
Reguliere functies hebben prioriteit boven sjabloonfuncties bij overeenkomsten in handtekeningen.
Standaardwaarden voor sjabloonparameters worden alleen toegepast wanneer ze ontbreken in de expliciete aanroep.

Vragen met een knipoog.

Is het mogelijk om standaardparameters in een latere definitie van een sjabloonfunctie te declareren?

Nee, de standaardwaarde kan alleen op één plaats worden opgegeven (meestal in de verklaring), anders leidt dit tot een compilatiefout.

Wat gebeurt er bij ambiguïteit tussen een sjabloon en een niet-sjabloonfunctie? Hoe kiest de compiler wat aan te roepen?

De compiler geeft altijd de voorkeur aan de niet-sjabloonfunctie als deze precies past op de argumenten. De sjabloon wordt alleen aangeroepen als er geen exacte overeenkomst is.

Is het mogelijk om standaardwaarden op te geven voor niet-type sjabloonparameters (bijvoorbeeld voor een getal)?

Ja, bijvoorbeeld:

template<typename T, int N = 8>
class Array {
    T data[N];
};

Typische fouten en anti-patronen

Het gelijktijdig declareren van standaardwaarden op meerdere plaatsen.
Onduidelijke ambiguïteit tussen sjabloon- en reguliere functies.
Overmatig gebruik van standaardparameters, wat het lezen en debuggen van code bemoeilijkt.

Voorbeeld uit de praktijk

Negatieve casus

Er zijn zowel een sjabloon- als een niet-sjabloonfunctie gedefinieerd met overeenkomende parameters en standaardwaarden. In één module werkt de aanroep zoals bedoeld, terwijl in een andere module onverwachts een andere versie van de functie wordt gekozen.

Voordelen:

Handig om aan te roepen zonder typeopgave.

Nadelen:

Niet-voor-de-hand-liggende fouten en verwarrende aanroeplogica.

Positieve casus

Voor overlappende configuraties zijn expliciet verschillende namen gedefinieerd voor sjabloon- en niet-sjabloonfuncties, met standaardwaarden alleen in één van de versies.