C++ Tutorial/template/template function

Материал из C\C++ эксперт
Перейти к: навигация, поиск

function template: GetMax

#include <iostream.h>
template <class T>
T GetMax (T a, T b) {
  T result;
  result = (a>b)? a : b;
  return (result);
}
int main () {
  int i=5, j=6, k;
  long l=10, m=5, n;
  k = GetMax< int >(i,j);
  n = GetMax< long >(l,m);
  cout << k << endl;
  cout << n << endl;
  return 0;
}
6
10

Function template: swapargs

#include <iostream> 
using namespace std; 
 
// This is a function template. 
template <class X> void swapargs(X &a, X &b) 
{ 
  X temp; 
 
  temp = a; 
  a = b; 
  b = temp; 
} 
 
int main() 
{ 
  int i=1, j=2; 
  float x=1.1, y=2.3; 
  char a="x", b="z"; 
 
  cout << "Original i, j: " << i << " " << j << "\n"; 
  swapargs(i, j); // swap integers 
  cout << "Swapped i, j: " << i << " " << j << "\n"; 
  
  
  cout << "Original x, y: " << x << " " << y << "\n"; 
  swapargs(x, y); // swap floats 
  cout << "Swapped x, y: " << x << " " << y << "\n"; 
  
  cout << "Original a, b: " << a << " " << b << "\n"; 
  swapargs(a, b); // swap chars 
  cout << "Swapped a, b: " << a << " " << b << "\n"; 
 
  return 0; 
}
6
10

Function with generic parameters

#include <iostream>
using namespace std;
template <class type1, class type2>
void f(type1 x, type2 y)
{
  cout << x << " " << y << "\n";
}
int main()
{
  f(10, "AAAAA");
  f(98.6, 19L);
  
  f("C", "V");
  f("C", 0);
  
  return 0;
}
10 AAAAA
98.6 19
C V
C 0

Namespace with template function

/* The following code example is taken from the book
 * "C++ Templates - The Complete Guide"
 * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
 *
 * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
#include <iostream>
namespace X {
    template<typename T> void f(T);
}
namespace N {
    using namespace X;
    enum E { e1 };
    void f(E) {
        std::cout << "N::f(N::E) called\n";
    }
}
void f(int)
{
    std::cout << "::f(int) called\n";
}
int main()
{
    ::f(N::e1);  // qualified function name: no ADL
    f(N::e1);    // ordinary lookup finds ::f() and ADL finds N::f(),
}                //  the latter is preferred
::f(int) called
N::f(N::E) called

Overload a function template declaration

#include <iostream>
using namespace std;
template <class X> void f(X a)
{
  cout << "Inside f(X a)\n";
}
template <class X, class Y> void f(X a, Y b)
{
  cout << "Inside f(X a, Y b)\n";
}
int main()
{
  f(10);     // calls f(X)
  f(10, 20); // calls f(X, Y)
  return 0;
}
Inside f(X a)
Inside f(X a, Y b)

Overload template function

/* The following code example is taken from the book
 * "C++ Templates - The Complete Guide"
 * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
 *
 * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
#include <string>
#include <iostream>
template<typename T> 
std::string f(T) 
{ 
    return "Template"; 
}
std::string f(int&) 
{ 
    return "Nontemplate"; 
}
int main() 
{
    int x = 7;
    std::cout << f(x) << std::endl;
}
Nontemplate

reference and non-reference template function

/* The following code example is taken from the book
 * "C++ Templates - The Complete Guide"
 * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
 *
 * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
#include <typeinfo>
#include <iostream>
template <typename T>
void ref (T const& x)
{
    std::cout << "x in ref(T const&): "
              << typeid(x).name() << "\n";
}
template <typename T>
void nonref (T x)
{
    std::cout << "x in nonref(T):     "
              << typeid(x).name() << "\n";
}
int main()
{
    ref("hello");
    nonref("hello");
}
x in ref(T const&): A6_c
x in nonref(T):     PKc

Specify template argument explicitly and implicitly

/* The following code example is taken from the book
 * "C++ Templates - The Complete Guide"
 * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
 *
 * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b ? b : a;
}
int main()
{
    max<double>(1.0, -3.0);  // explicitly specify template argument
    max(1.0, -3.0);          // template argument is implicitly deduced
                             // to be double
    max<int>(1.0, 3.0);      // the explicit <int> inhibits the deduction;
                             // hence the result has type int
}

template function to display the number limits

#include <iostream>
#include <limits>
using namespace std;
template<typename T>
void showMinMax( ) {
  cout << "min: " << numeric_limits<T>::min( ) << endl;
  cout << "max: " << numeric_limits<T>::max( ) << endl << endl;
}
int main( ) {
  cout << "short:" << endl;
  showMinMax<short>( );
  cout << "int:" << endl;
  showMinMax<int>( );
  cout << "long:" << endl;
  showMinMax<long>( );
  cout << "float:" << endl;
  showMinMax<float>( );
  cout << "double:" << endl;
  showMinMax<double>( );
  cout << "long double:" << endl;
  showMinMax<long double>( );
  cout << "unsigned short:" << endl;
  showMinMax<unsigned short>( );
  cout << "unsigned int:" << endl;
  showMinMax<unsigned int>( );
  cout << "unsigned long:" << endl;
  showMinMax<unsigned long>( );
}
short:
min: -32768
max: 32767
int:
min: -2147483648
max: 2147483647
long:
min: -2147483648
max: 2147483647
float:
min: 1.17549e-038
max: 3.40282e+038
double:
min: 2.22507e-308
max: 1.79769e+308
long double:
min: 0
max: 1.#INF
unsigned short:
min: 0
max: 65535
unsigned int:
min: 0
max: 4294967295
unsigned long:
min: 0
max: 4294967295

template function to get the maximum of three values of any type (call-by-reference)

/* The following code example is taken from the book
 * "C++ Templates - The Complete Guide"
 * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
 *
 * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
#include <iostream>
#include <cstring>
#include <string>
// maximum of two values of any type (call-by-reference)
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}
// maximum of two C-strings (call-by-value)
inline char const* max (char const* a, char const* b)
{
    return  std::strcmp(a,b) < 0  ?  b : a;
}
// maximum of three values of any type (call-by-reference)
template <typename T>
inline T const& max (T const& a, T const& b, T const& c)
{
    return max (max(a,b), c);  // error, if max(a,b) uses call-by-value
}
int main ()
{
    std::cout << ::max(7, 42, 68);     // OK
    const char* s1 = "frederic";
    const char* s2 = "anica";
    const char* s3 = "lucas";
    //::max(s1, s2, s3);    // ERROR
}
68"

template function to get the maximum of two values

/* The following code example is taken from the book
 * "C++ Templates - The Complete Guide"
 * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
 *
 * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
// maximum of two int values
#include <iostream>
using namespace std;
inline int const& max (int const& a, int const& b)
{
    return  a < b ? b : a;
}
// maximum of two values of any type
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b ? b : a;
}
// maximum of three values of any type
template <typename T>
inline T const& max (T const& a, T const& b, T const& c)
{
    return ::max (::max(a,b), c);
}
int main()
{
    cout <<"\n\n" <<::max(7, 42, 68);     // calls the template for three arguments
    cout <<"\n\n" <<::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    cout <<"\n\n" <<::max("a", "b");      // calls max<char> (by argument deduction)
    cout <<"\n\n" <<::max(7, 42);         // calls the nontemplate for two ints
    cout <<"\n\n" <<::max<>(7, 42);       // calls max<int> (by argument deduction)
    cout <<"\n\n" <<::max<double>(7, 42); // calls max<double> (no argument deduction)
    cout <<"\n\n" <<::max("a", 42.7);     // calls the nontemplate for two ints
}
68
42
b
42
42
42
97"

template function to print elements of an STL container

/* The following code example is taken from the book
 * "C++ Templates - The Complete Guide"
 * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
 *
 * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
#include <iostream>
// print elements of an STL container
template <typename T>
void printcoll (T const& coll)
{
    typename T::const_iterator pos;  // iterator to iterate over coll
    typename T::const_iterator end(coll.end());  // end position
    for (pos=coll.begin(); pos!=end; ++pos) {
        std::cout << *pos << " ";
    }
    std::cout << std::endl;
}

#include <vector>

int main()
{
    std::vector<int> v;
    v.push_back(42);
    v.push_back(13);
    v.push_back(7);
    printcoll(v);
}
42 13 7

template type

#include <iostream> 
using namespace std; 
 
template <class Type1, class Type2> 
void myfunc(Type1 x, Type2 y) 
{ 
  cout << x << " " << y << "\n"; 
} 
 
int main() 
{ 
  myfunc(10, "hi"); 
 
  myfunc(0.23, 10L); 
 
  return 0; 
}
10 hi
0.23 10

Using standard parameters in a template function

#include <iostream>
using namespace std;
const int TABWIDTH = 8;
template<class X> void f(X data, int tab)
{
    cout << "tab=" << tab;
    
    cout << data << "\n";
}
int main()
{
  f("This is a test", 0);
  f(100, 1);
  f("X", 2);
  f(10/3, 3);
  return 0;
}
19525391970This is a test
19525391971100
19525391972X
195253919733
Источник — «http://cppe.ru/index.php?title=C%2B%2B_Tutorial/template/template_function&oldid=2585»