Templates are unnecessary in modern programming languages.

Templates reduce the performance of the code.

Templates are needed in programming for code reusability, flexibility, and type safety.

Templates are only used for documentation purposes.

A class template is a type of variable that holds data.

A class template is a blueprint for creating classes that can work with any data type.

A class template is a method for defining functions only.

A class template is a specific instance of a class.

Class templates are used for creating functions; function templates are used for creating data structures.

Function templates create reusable functions; class templates create reusable classes.

Function templates can only handle primitive types; class templates can handle any type.

Function templates require a specific return type; class templates do not have return types.

Templates can only have one function defined per name regardless of parameters.

Function overloading in templates allows multiple functions with the same name to be defined based on different template parameters.

Function overloading allows functions to have different names based on parameters.

Function overloading is not applicable in template programming.

Bubble sort algorithm sorts a list by merging two halves recursively until sorted.

Bubble sort algorithm sorts a list by repeatedly swapping adjacent elements if they are in the wrong order, continuing until no swaps are needed.

Bubble sort algorithm sorts a list by inserting elements into their correct position one at a time.

Bubble sort algorithm sorts a list by selecting the largest element and placing it at the end.

Templates offer type safety, better error checking, and support for generic programming, while macros can complicate debugging and reduce code readability.

Templates are only useful for simple data types.

Macros provide better type safety than templates.

Templates are slower than macros in execution.

Templates are only useful for organizing code structure.

Templates require manual code duplication for each data type.

Templates enhance code reusability by allowing the same code to work with different data types without duplication.

Templates only work with a single data type.

functionName(T parameter) { // function body }

template function T functionName(T parameter) { // function body }

template T functionName(T parameter) { // function body }

template functionName(T parameter) { // function body }

User-defined types are incompatible with templates.

No, templates can only be used with built-in types.

Templates cannot be used with any data types.

Yes, templates can be used with user-defined types.

template void bubbleSort(T arr[], int n) { for (int i = 0; i < n; i++) { for (int j = 0; j < n-i; j++) { if (arr[j] < arr[j+1]) { std::swap(arr[j], arr[j+1]); } } } }

template void bubbleSort(T arr[], int n) { for (int i = 0; i < n; i++) { for (int j = 0; j < n-i; j++) { if (arr[j] == arr[j+1]) { std::swap(arr[j], arr[j+1]); } } } }

template void bubbleSort(T arr[], int n) { for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { std::swap(arr[j], arr[j+1]); } } } }

void bubbleSort(int arr[], int n) { for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] < arr[j+1]) { std::swap(arr[j], arr[j+1]); } } } }

O(log n)

O(n log n)

O(n)

O(n^2)

Bubble sort is the fastest sorting algorithm available.

Bubble sort is more efficient than insertion sort.

Bubble sort is less efficient than advanced sorting algorithms like quicksort and mergesort.

Bubble sort can sort data in linear time.

Templates support all types of polymorphism

Templates improve code readability

Limitations of using templates in C++ include increased compilation times, code bloat, complex error messages, reduced readability, and limited polymorphism support.

Templates reduce compilation times

Create an instance with ClassName instanceName;

Use the syntax instanceName>;

Instantiate using ClassName = new instanceName;

Use the syntax ClassName instanceName; to instantiate a class template.

Non-template functions can handle multiple data types, while template functions cannot.

Template functions require more memory than non-template functions.

Template functions are always faster than non-template functions.

The main difference is that template functions are generic and can handle multiple data types, while non-template functions are specific to a single data type.

Use templates to create a static array for the linked list.

Implement a linked list without any node structure.

Use templates to define a generic node structure for the linked list.

Define a linked list using only integer data types.

The 'typename' keyword is used to create a new template class.

The 'typename' keyword specifies the return type of a function.

The 'typename' keyword is used to define a variable in a function.

The 'typename' keyword indicates that a dependent name in a template is a type.

Ignore errors completely

Implement try-catch blocks, validate inputs, log errors, and provide user-friendly messages.

Display raw error messages to users

Assume all inputs are valid

Template specialization is a method for creating new classes in C++.

Template specialization allows for the creation of global variables in C++.

Template specialization is used to optimize memory usage in C++.

Template specialization is a feature in C++ that allows defining specific implementations of a template for particular types.

The 'template' keyword is used to define a function that can operate on different data types.

The 'template' keyword is used to create a new data type.

The 'template' keyword is used to declare variables in a class.

The 'template' keyword is used to define constants in C++.

By using a static array to hold the stack elements.

By creating a function template for stack operations.

By implementing a stack using only integer data types.

By defining a class template that includes methods for push, pop, and peek operations.

'typename' is used to define a new class, while 'class' is used for function templates.

'typename' and 'class' serve different purposes and cannot be used interchangeably.

'typename' is used for type parameters, while 'class' is used for class parameters only.

Both 'typename' and 'class' can be used interchangeably to define template parameters.

Function templates are used for creating functions, while class templates are used for creating classes.

There is no difference; both serve the same purpose in programming.

Function templates can be specialized, but class templates cannot.

Class templates can only handle primitive data types, whereas function templates can handle any type.

Template metaprogramming only affects runtime performance.

Template metaprogramming has no effect on compile-time performance.

Template metaprogramming can significantly reduce compile-time performance due to increased complexity.

Template metaprogramming can improve compile-time performance by enabling optimizations.

By using a static array to hold the queue elements.

By creating a function template for queue operations.

By implementing a queue using only integer data types.

By defining a class template that includes methods for enqueue, dequeue, and front operations.

Template parameters restrict the types that can be used in a function.

Template parameters are only for internal use within a function.

Template parameters are used to define constants in a program.

Template parameters allow functions and classes to operate with any data type.

By defining a class template that includes methods for insertion, deletion, and traversal.

By using a static array to hold the tree elements.

By implementing a binary tree using only integer data types.

By creating a function template for tree operations.

It is a syntax error in C++.

It defines a template that can accept any data type as a parameter.

It is used to declare a new class in C++.

It restricts the template to only integer types.

Class templates allow for the creation of classes that can operate with any data type, enhancing code reusability.

Class templates are not compatible with inheritance.

Class templates are only useful for primitive data types.

Class templates reduce the performance of the code.