Templates Quiz - Languages C++

Free practice quiz: Templates (Languages C++). 56 multiple-choice questions with answers and explanations. Play online, no sign-up needed.

This Languages C++ practice quiz has 56 multiple-choice questions on Templates, and 56 of them come with an explanation. Try the 5 sample questions below (tap an option to check yourself), then play the full quiz online. No sign-up needed.

Sample questions

1. What is the primary purpose of C++ templates?

   1. To implement inheritance between classes.
   2. To achieve runtime polymorphism.
   3. To allow writing generic code that works with different data types.
   4. To manage memory allocation automatically.
   Show answer

   Answer: C. To allow writing generic code that works with different data types.

   C++ templates enable the creation of generic classes and functions, allowing them to operate on various data types without needing to rewrite the code for each type. This promotes code reusability and type safety.

2. What is a 'primary template' in C++?

   1. The first template definition encountered.
   2. The most specialized version of a template.
   3. The general template definition from which specific instances are generated or specialized versions are derived.
   4. A template that cannot be instantiated directly.
   Show answer

   Answer: C. The general template definition from which specific instances are generated or specialized versions are derived.

   The primary template is the main, most general definition of a class or function template. All other template specializations (explicit and partial) are derived from or provide specific implementations for this primary template.

3. In a template function like `template <typename T> void process(T& value);`, what is `T&`?

   1. A reference to a generic type.
   2. A pointer to a generic type.
   3. A constant reference to a generic type.
   4. A function taking a generic type by value.
   Show answer

   Answer: A. A reference to a generic type.

   `T&` signifies that `T` is a template parameter representing a type, and the function parameter `value` is a reference to an object of that type `T`. This allows the function to modify the original object passed to it.

4. Consider `template <typename T> struct Foo { typedef T type; };`. What is the purpose of `typedef T type;`?

   1. To create a data member named `type`.
   2. To define a type alias for the template parameter `T` within the `Foo` struct.
   3. To declare a function named `type`.
   4. To indicate that `Foo` is a type.
   Show answer

   Answer: B. To define a type alias for the template parameter `T` within the `Foo` struct.

   The `typedef T type;` statement creates a member type alias named `type` within the `Foo` struct. This alias refers to the type `T` that was used to instantiate `Foo`.

5. What is the role of `std::make_tuple`?

   1. To define a new tuple type.
   2. To create a tuple object, often with type deduction.
   3. To destroy a tuple object.
   4. To resize a tuple.
   Show answer

   Answer: B. To create a tuple object, often with type deduction.

   `std::make_tuple` is a helper function that constructs a `std::tuple` object from its arguments. It's convenient because it deduces the types of the elements, similar to `std::make_pair`.

More questions in this quiz

Answers and explanations are in the full quiz.

1. Which of the following best describes a template instantiation?
2. Consider the following template function: `template <typename T> void print(T value) { std::cout << value << std::endl; }`. What happens when you call `print(5)`?
3. What is a non-type template parameter?
4. Which mechanism allows you to provide a specific implementation for a template when certain conditions are met?
5. What does `template <typename T, size_t N> class Array { ... };` signify?
6. What is the difference between `template <class T>` and `template <typename T>`?
7. What is a 'dependent name' in the context of C++ templates?
8. When is `typename` keyword strictly required within a template definition?
9. Consider the following code: `template <typename T> struct Foo { typedef T value_type; };`. What is `Foo<int>::value_type`?
10. What is template argument deduction?
11. Which of the following is an example of explicit template specialization?
12. What is partial template specialization?
13. Consider `template <typename T> class Container { ... };` and `template <typename T> class Container<T*> { ... };`. What is the second declaration?
14. What is the purpose of `template <typename T> void foo(T* ptr) {}`?
15. What is template metaprogramming?
16. Consider `template <int N> struct Factorial { static const int value = N * Factor<N - 1>::value; };`. What is the base case for this template metaprogramming example?
17. What does `template <typename T> using VectorAlias = std::vector<T, std::allocator<T>>;` achieve?
18. What is a potential drawback of excessive template instantiation?
19. Which keyword is used to provide a default template argument?
20. What is the primary advantage of using `std::enable_if` in template metaprogramming?
21. What does `template <auto V> void printValue() { std::cout << V << std::endl; }` enable?
22. What is SFINAE in the context of templates?
23. Consider `template <typename T> struct Traits { static constexpr bool is_fundamental = false; };` and `template <typename T> struct Traits<const T> { static constexpr bool is_fundamental = Traits<T>::is_fundamental; };`. What would `Traits<const int>::is_fundamental` evaluate to if `Traits<int>::is_fundamental` were `true`?
24. What is the purpose of `template <typename T> class Container { ... T* data; ... };` and `template <typename T> class Container<T*> { ... T** data; ... };`?
25. What is a template parameter pack?
26. How do you expand a template parameter pack?
27. What is a 'variadic template'?
28. Consider `template <typename... Args> void printArgs(Args... args) { ... }`. What is `Args... args`?
29. What is the purpose of `constexpr` in relation to templates?
30. What is the primary mechanism for conditional compilation in C++ templates?
31. What is an example of a type trait used with templates?
32. What is the purpose of `template <typename T, typename Allocator = std::allocator<T>> class MyContainer { ... };`?
33. What does `template <typename T> requires std::is_integral_v<T> void foo(T value);` signify (C++20 Concepts)?
34. What is a template alias (using declaration)?
35. Consider `template <typename T> struct Foo { static T value; };`. What must be done to use this template?
36. What is the benefit of template metaprogramming for compile-time calculations like factorial?
37. What is a 'template template parameter'?
38. Consider `template <template <typename> class Container> void processContainer(Container<int>& c) { ... }`. What is `template <typename> class Container`?
39. What is the primary purpose of `std::tuple`?
40. How do you access elements in a `std::tuple`?
41. What does `template <typename T, int Size> class FixedArray { T data[Size]; };` represent?
42. What is a 'dependent type' in the context of templates?
43. What does `template <typename T> void func(T t);` and `template <> void func(int t);` demonstrate?
44. What is the primary goal of C++ templates?
45. What is the difference between `template <class T> class Container;` and `template <typename T> class Container;`?
46. What does `template <typename T> struct Foo { static const T value; };` require for instantiation?
47. What is the purpose of `decltype` in conjunction with templates?
48. Which C++ standard introduced variadic templates?
49. What is the typical use case for `std::array`?
50. What is the purpose of `template <auto Value> void func() { ... }` in C++17?
51. What is a common pattern for implementing recursive template metaprogramming?

More quizzes

• Memory Management▶ Play
• Multithreading▶ Play
• OOP▶ Play
• STL▶ Play

Browse all C++ quizzes

More to play