What Do We Type In Place Of T In Template Specialization
Contents [Show]
-
- Specialization of Class Templates as a Compile-Time if
- std::is_same
- Metafunctions and Metadata
- Metadata
- Metafunction
- Member Functions of Specialization Defined Outside the Class Body
- What's next?
- Specialization of Class Templates as a Compile-Time if
After I presented in my last post Template Specialization the basics about template specialization, I dig today deeper. I want to present the partial and full specialization of a class template as a compile-time if.
Specialization of Class Templates as a Compile-Time if
After my last blog post Template Specialization, I got a few similar questions. How can you decide if a type is a given type or two types are the same? Answering these questions is easier than it seems and helps me to present more theories about class template specialization. To answer these questions, I implement simplified versions of std::is_same and std::remove_reference. The presented techniques in this post are an application of class template specialization and are a compile-time if.
std::is_same
std::is_same is a function from the type-traits library. It returns std::true_type if both types are the same, otherwise it returns std::false_type. For simplicity reasons, I return true or false.
// isSame.cpp #include <iostream> template < typename T, typename U> // (1) struct isSame { static constexpr bool value = false; }; template < typename T> // (2) struct isSame<T, T> { static constexpr bool value = true; }; int main() { std::cout << '\n'; std::cout << std::boolalpha; // (3) std::cout << "isSame<int, int>::value: " << isSame< int, int >::value << '\n'; std::cout << "isSame<int, int&>::value: " << isSame< int, int &>::value << '\n'; int a(2011); int & b(a); // (4) std::cout << "isSame<decltype(a), decltype(b)>::value " << isSame<decltype(a), decltype(b)>::value << '\n'; std::cout << '\n'; }
The primary template (1) returns as default false, when you ask for its value. On the contrary, the partial specialization (2) that is used when both types are the same returns true. You can use the class template isSame on types (3) and, thanks to decltype, on values (4). The following screenshot shows the output of the program.
You may already guess it. The class template isSame is an example of template metaprogramming. Now, I have to make a short detour and write a few words about meta.
Metafunctions and Metadata
At runtime, we use data and functions. At compile time, we use metadata and metafunctions. Quite easy, it's called meta because we do metaprogramming, but what is metadata or a metafunction? Here is the first definition.
- Metadata: Types and integral values that are used in metafunctions.
- Metafunction: Functions that are executed at a compile time.
Let me elaborate more on the terms metadata and metafunction.
Metadata
Metadata includes three entities:
- Types such as int, double, or
std::string - Non-types such as integrals, enumerators, pointers, lvalue reference, and floating-point values with C++20
- Templates
So far, I only used types in my metafunction isSame.
Metafunction
Types such as the class template isSame are used in template metaprogramming to simulate functions. Base on my definition of metafunctions, constexpr functions can also be executed at compile time and are, therefore, metafunctions.
A metafunction cannot only return a value, but it can also return a type. By convention, a metafunction returns a using via ::value, and a type using ::type.The following metafunction removeReference returns a type as result.
// removeReference.cpp #include <iostream> #include <utility> template < typename T, typename U> struct isSame { static constexpr bool value = false; }; template < typename T> struct isSame<T, T> { static constexpr bool value = true; }; template < typename T> // (1) struct removeReference { using type = T; }; template < typename T> // (2) struct removeReference<T&> { using type = T; }; template < typename T> // (3) struct removeReference<T&&> { using type = T; }; int main() { std::cout << '\n'; std::cout << std::boolalpha; // (4) std::cout << "isSame<int, removeReference<int>::type>::value: " << isSame< int, removeReference< int >::type>::value << '\n'; std::cout << "isSame<int, removeReference<int&>::type>::value: " << isSame< int, removeReference< int &>::type>::value << '\n'; std::cout << "isSame<int, removeReference<int&&>::type>::value: " << isSame< int, removeReference< int &&>::type>::value << '\n'; // (5) int a(2011); int & b(a); std::cout << "isSame<int, removeReference<decltype(a)>::type>::value: " << isSame< int, removeReference<decltype(a)>::type>::value << '\n'; std::cout << "isSame<int, removeReference<decltype(b)>::type>::value: " << isSame< int, removeReference<decltype(b)>::type>::value << '\n'; std::cout << "isSame<int, removeReference<decltype(std::move(a))>::type>::value: " << isSame< int, removeReference<decltype(std::move(a))>::type>::value << '\n'; std::cout << '\n'; }
In this example, I apply the previously defined metafunction isSame and the metafunction removeReference. The primary template removeReference (1) returns T using the name type. The partial specializations for the lvalue reference (2) and the rvalue reference also return T by removing the references from it's template parameter. As before, you can use the metafunction removeReference with types (4) and, thanks to decltype, with values (5). decltype(a) returns a value, decltype(b) returns an lvalue reference, and decltype(std::move(a)) returns an rvalue reference.
Finally, here is the output of the program.
There is one trap I fall into. When you define a member function of a fully specialized class template outside the class, you must not use template<>.
Member Functions of Specialization Defined Outside the Class Body
The following code program shows the class template Matrix, having a partial and a full specialization.
// specializationExtern.cpp #include <cstddef> #include <iostream> template < typename T, std:: size_t Line, std:: size_t Column> // (1) struct Matrix; template < typename T> // (2) struct Matrix<T, 3, 3 >{ int numberOfElements() const; }; template < typename T> int Matrix<T, 3, 3 >::numberOfElements() const { return 3 * 3; }; template <> // (3) struct Matrix< int, 4, 4 >{ int numberOfElements() const; }; // template <> // (4) int Matrix< int, 4, 4 >::numberOfElements() const { return 4 * 4; }; int main() { std::cout << '\n'; Matrix< double, 3, 3 > mat1; // (5) std::cout << "mat1.numberOfElements(): " << mat1.numberOfElements() << '\n'; Matrix< int, 4, 4 > mat2; // (6) std::cout << "mat2.numberOfElements(): " << mat2.numberOfElements() << '\n'; std::cout << '\n'; }
(1) declares the primary template. (2) defines the partial specialization and (3) the full specialization of Matrix. The member functions numberOfElements are defined outside the class body. Line (4) is probably the non-intuitive line. When you define the member function numberOfElements outside the class body, you must not use template <>. Line (5) causes the instantiation of the partial and line (6) the instantiation of the full specialization.
What's next?
In my next post, I write about the full specialization of function templates and their surprising interplay with functions. To make a long story short, according to the C++ Core Guidelines holds: T.144: Don't specialize function templates.
Thanks a lot to my Patreon Supporters : Matt Braun, Roman Postanciuc, Tobias Zindl, Marko, G Prvulovic, Reinhold Dröge, Abernitzke, Frank Grimm , Sakib, Broeserl, António Pina, Sergey Agafyin, Андрей Бурмистров, Jake, GS, Lawton Shoemake, Animus24, Jozo Leko, John Breland, espkk, Louis St-Amour, Venkat Nandam, Jose Francisco, Douglas Tinkham, Kuchlong Kuchlong, Robert Blanch, Truels Wissneth, Kris Kafka, Mario Luoni, Neil Wang, Friedrich Huber, lennonli, Pramod Tikare Muralidhara, Peter Ware, Tobi Heideman, Daniel Hufschläger, Red Trip, Alexander Schwarz, Alessandro Pezzato , Evangelos Denaxas, Bob Perry, Satish Vangipuram, Andi Ireland, Richard Ohnemus, Michael Dunsky, Dimitrov Tsvetomir, Leo Goodstadt, Eduardo Velasquez, John Wiederhirn, Yacob Cohen-Arazi, Florian Tischler, Robin Furness, Michael Young, Holger Detering, Haken Gedek, and Bernd Mühlhaus.
Thanks in particular to Jon Hess, Lakshman, Christian Wittenhorst, Sherhy Pyton, Dendi Suhubdy, Sudhakar Belagurusamy, Richard Sargeant, and Rusty Fleming.
My special thanks to Embarcadero 
My special thanks to PVS-Studio 
Seminars
I'm happy to give online seminars or face-to-face seminars worldwide. Please call me if you have any questions.
Bookable (Online)
German
- Clean Code: Best Practices für modernes C++: 14.12.2021 - 16.12.2021 (Termingarantie)
- Design Pattern und Architekturpattern mit C++: 05.04.2022 - 07.04.2022
- Embedded Programmierung mit modernem C++: 28.06.2022 - 30.06.2022
- C++20: 23.08.2022 - 25.08.2022
Standard Seminars (English/German)
Here is a compilation of my standard seminars. These seminars are only meant to give you a first orientation.
- C++ - The Core Language
- C++ - The Standard Library
- C++ - Compact
- C++11 and C++14
- Concurrency with Modern C++
- Design Patterns and Architecture Patterns with C++
- Embedded Programming with Modern C++
- Generic Programming (Templates) with C++
New
- Clean Code with Modern C++
- C++20
Contact Me
- Phone: +49 152 31965939
- Mail: This email address is being protected from spambots. You need JavaScript enabled to view it.
- German Seminar Page: www.ModernesCpp.de
- English Seminar Page: www.ModernesCpp.net
Modernes C++,
What Do We Type In Place Of T In Template Specialization
Source: https://www.modernescpp.com/index.php/template-specialization-more-details
Posted by: bennettnetaid.blogspot.com
0 Response to "What Do We Type In Place Of T In Template Specialization"
Post a Comment