- How should a template function be defined with multiple return types?
- template <T, U> class functionName(U parameter)
- template class <T, U> functionName(U parameter)
- template <class T, class U> T functionName(U parameter)
- template <T, U> functionName(T parameter)
Explanation:
The correct answer is option "a". This syntax defines a template function called functionName using T and U as type parameters. A type U parameter is received by the function, which returns a type T value. It provides versatility in the kinds that the function may handle by allowing it to operate with different types for both its input and return values. In the creation of the template, T and U are placeholders for the types that will be provided. While the parameter type is U, T determines the return type of the function.
- What is the purpose of template argument deduction?
- To explicitly instantiate templates
- To automatically infer the type of template arguments based on function calls.
- To manually specify template arguments
- To create template specializations
Explanation:
The correct answer is option "b". By using the types of arguments passed to a template function, the compiler may automatically infer the types of template parameters. This process is known as template argument deduction. This feature makes it simpler to utilize templates because it eliminates the need for the programmer to explicitly define the template parameters, which results in more readable and concise code. The compiler determines the proper template parameter types based on an analysis of the provided argument types when a function template is called.
- What is the purpose of a template alias?
- To specialize in a template
- To overload a function template
- To create a function template
- To create a shorthand for a template type or class
Explanation:
The correct answer is option "d". C++11 introduced the ability to generate a more readable or simple name for a complex template type or class, which is called a template alias. This feature creates an alias that can help simplify and preserve the code. For code with lengthy or nested template types, template aliases are quite helpful in cutting down on verbosity and making the code easier to understand.
- How should a member function of a template class be defined when using a type alias?
- template <class T> TypeAlias = ClassName<T>;
- template <T> using ClassName<T> = TypeAlias;
- template <class T> using TypeAlias = ClassName<T>;
- template <class T
Explanation:
The accurate choice is option "c". This particular syntax establishes a type alias named TypeAlias for a template class ClassName with the parameter T. By utilizing the using keyword, TypeAlias is effectively equated to ClassName. This simplifies the usage of the template class by providing a shorter notation, enhancing code readability, and reducing redundancy when referencing the template class multiple times.
#include <iostream>
template <typename T>
T square(T value) {
return value * value;
}
int main()
{
std::cout << square<float>(3.0);
return 0;
}
- Compilation error
Explanation:
The correct choice is option "d". The square function template takes a type T parameter and calculates the square of that parameter. In this case, T is set as a float when square(3.0) is called in the main function. Consequently, the function determines the result of 3.0 * 3.0, which is 9.0. When the program runs, 9 is printed to the standard output. The program executes without any compilation errors, and the expected result of the floating-point multiplication is achieved.
#include <iostream>
template <class T>
T divide(T a, T b) {
return a / b;
}
int main()
{
std::cout << divide<double>(10.0, 2.0);
return 0;
}
- Compilation error
Explanation:
The accurate selection is choice "a". The function divide(10.0, 2.0) performs the operation 10.0 / 2.0, resulting in 5.0. When displayed using std::cout, the output appears as 5, denoting the integer value of 5. The process encounters no compilation issues and executes a basic floating-point division. The divide function template accepts two arguments of type T and produces the result of their division. Within the main function, the function is invoked with T defined as a double data type.
