The C++ programming languages offer some exciting and useful features to the programmers. You can perform various awesome things with C++. In C++, It is one of the most efficient and useful features. Using Templates, you can write generic programs in C++. Let us learn more about C++ templates.<\/p>\n
To put it short, using Templates, you can write a single function or a class to work with different data types. It is a powerful tool to use. With the help of templates, you can pass the data type as a parameter. With this, you don\u2019t have to write the same code for different data types.<\/p>\n
Suppose, in a company, you have to sort() for different data types. So, for this, you can write one sort() and pass data type as a parameter.<\/p>\n
In C++, Templates can be represented in two ways:-<\/p>\n
You can define a template for a function. It works similarly like a function but it has one key difference. A normal function can work with one set of data types. But with the help of templates, you can work with different data types at once. Using Templates, you can perform the task while writing less and maintainable code.<\/p>\n
Syntax of C++ Function Template<\/strong><\/p>\n Above, type is a placeholder name for the data type that is used by the function. The placeholder will automatically get replaced with the actual data type by the compiler.<\/p>\n Example of Simple Function Template in C++<\/strong><\/p>\n Output:-<\/strong><\/p>\n Above, we created a function() add which will perform addition on any data type.<\/p>\n You can also use multiple parameters in your function template.<\/p>\n Syntax:-<\/strong><\/p>\n The above syntax will accept any number of arguments of different types.<\/p>\n Example of Function Template with multiple parameters<\/strong><\/p>\n Output:-<\/strong><\/p>\n Above, we used two generic types such as A and B in the template function.<\/p>\n You can also overload a function template in C++.<\/p>\n Example of Function Template Overload<\/strong><\/p>\n Output:-<\/strong><\/p>\n Above, the func() function is overloaded.<\/p>\n It is the same as the normal function but for generic functions, the data type differs. Let\u2019s take a simple example below:-<\/p>\n Output:-<\/strong><\/p>\n Above, we have just overloaded the normal functions. But we cannot overload the generic functions because both the functions have different functionalities.<\/p>\n You can also create class templates similarly like function templates.<\/p>\n In some cases, you will need a class implementation that is the same for all the classes. The only thing is that the data types that are used are different. Generally, you would have to create a class for each data type. And because of that, your code will get complex and hard to understand.<\/p>\n To avoid that, you can make use of class templates. Using class templates, you can reuse the same code for all data types.<\/p>\n Syntax of C++ Class Template:-<\/strong><\/p>\n From above, T is a placeholder for the data type used. It is also known as the template argument.<\/p>\n If you want to create a class template object then you will have to define the data type inside <> during creation.<\/p>\n Example:-<\/strong><\/p>\n Example:- Class Template<\/strong><\/p>\n Output:-<\/strong><\/p>\n Above, we created a template for class Add and within the main() function, we created the instance of class Add.<\/p>\n You can also use multiple parameters in your class template. Example:- Class Template with multiple parameters<\/strong><\/p>\n Output:-<\/strong><\/p>\n In template arguments, we can also use non-type template arguments. We can also use other types of arguments like strings, function names, constant names, built-in types.<\/p>\n Example:-<\/strong><\/p>\n In above example, element is the non-type template argument. You can specify arguments while creating the objects of the class:-<\/p>\n Example:- Non-type Template argument<\/strong><\/p>\n Output:-<\/strong><\/p>\n Templates are like macros that are expanded at compile time. The only difference is that before template expansion, the compiler does type checking. The source code will only contain the function or class but the compiled code will contain multiple copies of the same function or class.<\/p>\n Let me tell you that function overloading and function templates are examples of polymorphism which is one of the most useful features of OOP. We use function templates when multiple functions perform identical operations. And we use function overloading when multiple functions perform similar operations.<\/p>\n With the help of template specialization, you can write different code for a specific data type.<\/p>\n You can also specify default arguments to templates. Output:-<\/strong><\/p>\n There are various ways why you should use templates in C++.<\/p>\n In this tutorial, we discussed C++ templates and their working. We also discussed function and class templates and the difference between function templates and overloading.<\/p>\n","protected":false},"excerpt":{"rendered":" The C++ programming languages offer some exciting and useful features to the programmers. You can perform various awesome things with C++. In C++, It is one of the most efficient and useful features. Using...<\/p>\n","protected":false},"author":1,"featured_media":84624,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3405],"tags":[4213,4214],"class_list":["post-84047","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cpp","tag-c-templates","tag-importance-of-c-templates"],"yoast_head":"\ntemplate < class type> return_type_functionName(parameters) { \n\/\/ body \n} \n<\/pre>\n#include <iostream> \nusing namespace std; \ntemplate<class T> T add(T &i,T &j) \n{ \n T res = i+j; \n return res;\n} \nint main() \n{ \n int x =2; \n int y =3; \n cout<<\"The value of the addition of is: \"<<add(x,y); \n return 0; \n}\n<\/pre>\nFunction Templates with Multiple Parameters<\/h4>\n
template<class T1, class T2,.....> \nreturn_type functionName (arguments of type T1, T2....) { \n \/\/ body \n} \n<\/pre>\n#include <iostream> \nusing namespace std; \ntemplate<class A,class B> void func(A x,B y) \n{ \nstd::cout << \"Value->x: \" <<x<< std::endl; \nstd::cout << \"Value->y: \" <<y<< std::endl; \n} \nint main() \n{ \nfunc(15.2,1.3); \nreturn 0; \n}\n<\/pre>\n
\nValue->y: 1.3<\/div>\nOverloading a function Template in C++<\/h3>\n
#include <iostream> \nusing namespace std; \ntemplate<class A> void func(A x) \n{ \n std::cout << \"Value->x: \" <<x<< std::endl; \n} \ntemplate<class A,class B> void func(A y ,B z) \n{ \n std::cout << \"Value->y: \" <<y<< std::endl; \n std::cout << \"Value->z: \" <<z<< std::endl; \n} \nint main() \n{ \n func(20); \n func(2,2.1); \n return 0; \n}\n<\/pre>\n
\nValue->y: 2
\nValue->z: 2.1<\/div>\nGeneric Functions Restrictions<\/h3>\n
#include <iostream> \nusing namespace std; \nvoid func(double x) \n{ \n cout<<\"value of x is : \"<<x<<'\\n'; \n} \n \nvoid func(int y) \n{ \n if(y%2==0) \n { \n \tcout<<\"The Number is even!\"; \n } \n else \n { \n \tcout<<\"The Number is odd!\"; \n } \n \n} \n \nint main() \n{ \n func(3.2); \n func(5); \n return 0; \n}\n<\/pre>\n
\nThe Number is odd!<\/div>\nClass Template in C++<\/h3>\n
template <class T>\nclass Name_of_the_class\n{\n ... .. ...\n ... .. ...\n};\n<\/pre>\nCreate a class template object<\/h4>\n
Name_of_the_class<dataType> class_Object;<\/pre>\n
Name_of_the_class<int> class_Object;\nName_of_the_class<float> class_Object;\n<\/pre>\n
#include <iostream> \nusing namespace std; \ntemplate<class T> \nclass Add \n{ \n public: \n T n1 = 6; \n T n2 = 1; \n void addition() \n { \n \tstd::cout << \"n1+n2: \" << n1+n2<<std::endl; \n } \n \t \n}; \nint main() \n{ \n Add<int> data; \n data.addition(); \n return 0; \n}\n<\/pre>\nC++ Class Template with multiple parameters<\/h4>\n
\nSyntax:-<\/strong><\/p>\ntemplate<class T1, class T2, ......> \nclass Name_of_the_class \n{ \n \/\/ Body \n}\n<\/pre>\n#include <iostream> \nusing namespace std; \ntemplate<class T1, class T2> \nclass Tech \n{ \nT1 x; \nT2 y; \npublic: \nTech(T1 a,T2 b) \n{ \nx = a; \ny = b; \n} \nvoid print() \n{ \nstd::cout << \"The values of x and y: \" << x<<\" and \"<<y<<std::endl; \n} \n}; \nint main() \n{ \nTech<int,float> data(5,2.3); \ndata.print(); \nreturn 0; \n}\n<\/pre>\nNon type Template Arguments in C++<\/h3>\n
template<class T, int element> \nclass exp \n{ \nT a[element]; \n};\n<\/pre>\nexp<int, 15> t1; \nexp<float, 10> t2;\n<\/pre>\n
#include <iostream> \nusing namespace std; \ntemplate<class T, int element> \nclass Exp \n{ \n public: \n T a[element]; \n void put() \n { \n \tint x =1; \n \tfor (int j=0;j<element;j++) \n \t{ \n \ta[j] = x; \n \tx++; \n \t} \n } \n \t \n void print() \n { \n \tfor(int x=6;x<element;x++) \n \t{ \n \tstd::cout << a[x] << \" \"; \n \t} \n } \n}; \nint main() \n{ \n Exp<int,16> t1; \n t1.put(); \n t1.print(); \n return 0; \n}\n<\/pre>\nHow template works in C++?<\/h3>\n
Difference between C++ function overloading and templates<\/h3>\n
What is Template Specialization in C++?<\/h3>\n
Default value for template arguments<\/h3>\n
\nExample:-<\/strong><\/p>\n#include<iostream>\nusing namespace std;\ntemplate<class T1, class T2 = char>\nclass Tech{\npublic:\n T1 x;\n T2 y;\n Tech() { cout<<\"C++ Templates!\"<<endl; }\n};\n \nint main() {\n Tech<char> a; \n return 0;\n}\n<\/pre>\nImportance of C++ Templates<\/h3>\n
\n
Summary<\/h3>\n