Argumentafleiding voor Klasse-Templates
Veeg om het menu te tonen
Je hebt er misschien al een aantal gebruikt zonder je te realiseren dat het om templates ging, mogelijk dankzij Class Template Argument Deduction (CTAD).
Met C++17 kunnen we profiteren van Class Template Argument Deduction (CTAD). Deze functionaliteit maakt het mogelijk om instanties van templateklassen te maken zonder de template-typen expliciet op te geven. In plaats daarvan leidt de compiler de typen af op basis van de constructorparameters. Laten we enkele voorbeelden bekijken met std::pair.
main.cpp
12345678#include <iostream> #include <utility> // for std::pair int main() { std::pair<int, char> my_pair(1, 'a'); std::cout << my_pair.first << " : " << my_pair.second << std::endl; }
Voorheen was dit de enige manier om een instantie van std::pair te maken. Nu is het echter mogelijk om het gedeelte <int, char> weg te laten. Probeer het te verwijderen en voer de code opnieuw uit.
Deductie van klasse-templateargumenten wordt alleen uitgevoerd als er geen lijst met templateargumenten aanwezig is. Als er wel een lijst met templateargumenten is opgegeven, vindt er geen deductie plaats.
main.cpp
12345678#include <iostream> #include <utility> // for std::pair int main() { std::pair<> my_pair(1, 'a'); // Error std::cout << my_pair.first << " : " << my_pair.second << std::endl; }
Bij het aanmaken van een object met één argument dat overeenkomt met een specifiek type van een klasse-template, geeft CTAD de voorkeur aan het direct gebruiken van dat type, waardoor de instantiering voor zelfgedefinieerde templateklassen wordt vereenvoudigd. Bijvoorbeeld, met een templateklasse zoals Box kunnen gebruikers deze instantieren zonder type-argumenten te specificeren wanneer ze constructorargumenten opgeven.
main.cpp
123456789101112131415#include <iostream> template <typename T> class Box { T value; public: Box(T value): value(value) {} }; int main() { // No need to write Box<int> a{1}; Box a{1}; // Deduction: Box<int> Box b{a}; // Deduction: Box<int>, not Box<Box<int>> }
CTAD kan het onderhoud van code eenvoudiger maken. Als de onderliggende types veranderen, hoeft er minder code te worden aangepast, wat leidt tot minder kans op fouten.
vector.h
12345678template <typename T> class Vector3D { T x, y, z; public: Vector3D(T x, T y, T z) : x(x), y(y), z(z) {} }; Vector3D vec{1.0, 2.0, 3.0}; // CTAD deduces Vector3D<double>
Bij het gebruik van containers of wrappers met specifieke constructors kan CTAD de code vereenvoudigen. Stel dat je een aangepaste Matrix- of Vector-klasse hebt die een onderliggend gegevenstype omhult. Door hier CTAD te gebruiken, wordt het type automatisch afgeleid op basis van de opgegeven argumenten, wat de leesbaarheid en flexibiliteit verbetert.
Bedankt voor je feedback!
Vraag AI
Vraag AI
Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.
