c++ template笔记(1)模板函数

最新推荐文章于 2024-07-24 13:36:39 发布
原创 最新推荐文章于 2024-07-24 13:36:39 发布 · 994 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++

本文详细解析了C++中函数模板与模板函数重载的使用方法，包括如何定义函数模板、如何使用模板函数，以及如何解决模板参数默认值、返回类型等问题，并通过实例展示了模板函数重载的技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

二、function template不能有默认模板参数，如下则报错

 

int c = 10;//定义一个变量，用于作为T2的默认值

 

//为b设定一个默认参数

template < typename T1, typename T2 >

inline T1 max( const T1& a, const T2& b = c )

{

return a < b ? b : a;

}

 

int main()

{

//调用时出错，提示无法为T2进行类型推导

max( 4 );

return 0;

}

 

其中第二个参数用了默认参数，结果编译器提示错误“could not deduce template argument for 'T2'”。这点也class template不同，在class template中允许传入默认参数（class template后续讨论）。

 

三、对于上面的程序，不能以引用的（by reference）的方式返回值。如把程序改为

 

template < typename T1, typename T2 >

inline const T1& max( const T1& a, const T2& b )

{

return a < b ? b : a;

}

 

int main()

{

std::cout << max( 4, 5.2 ) << std::endl;

return 0;

}

 

输出是5，但程序是有问题的，因为返回值类型是int，对于5.2（编译器认为是double型），编译器会强制转换为int的5（此时编译器会有警告，提示从double转为int会导致精度的丢失），并用一个int的临时变量来保存返回的结果，最后将这个临时变量返回。我们知道，当函数的作用域结束时，临时变量会被释放掉，因此返回临时变量的引用或者地址（其实道理一样），都是不明智的，因此上面的程序只能返回T1，而不能返回T1&。

当然，如果类型相同，如max( 4, 5)都为整型，则不会出现上面的问题，但此时何不把T1和T2定义为相同的类型呢？如 inline const T& max( const T& a, const T& b )。实际上，为了保持代码的简单，推荐的做法便是尽量将函数模板的类型定义为相同的，即【单一类型】。

 

四、或许已经有人想到，其实可以再定义一个类型作为函数模板的返回类型，如下的RT

template<typename T1, typename T2, typename RT>

inline const RT& max( const T1& a, const T2& b );

 

但是请先明白，函数模板对于参数的推导，仅仅限于传入的调用参数，对于返回值的类型，推导机制并不会对其与返回值进行匹配，因此编译器无法推导出RT。

怎么办呢？既然编译器无法自己推导，那我们可以明确指定啊！因此对于上面的函数模板，我们可以使用这种方法调用max<int,double,double>(4, 5.2);<>中的第三个类型对应于返回类型RT。

 

为了少写一点参数，其实可以对模板中声明的类型顺序改变一下，因为函数模板的调用参数(call parameters)还是可以利用编译器自己去推导的，改后的声明如下

template<typename RT, typename T1, typename T2>

inline const RT& max( const T1& a, const T2& b );

调用方式max<double>(4, 5.2);//只需声明函数的返回类型是double

1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过


1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过




1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过




1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过

1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过




1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过


1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过

1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过

1.定义函数模板

template <typename T>
inline T const& max (T const& a, T const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

2.使用模板函数

#include <iostream>
#include <string>
#include "max.hpp"

int main()
{
    int i = 42;
    std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;

    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
}

输出结果

3.确定返回的参数

    ::max<double>(1,2); //ok
    //::max(1,1.2);//wrong
    ::max(static_cast<double>(4),4.1);//ok

若两个参数不正确，或者不支持模板定义的特性,编译时则会出错

4.多个模板参数

template <typename T1,typename T2>
inline T1 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

示例

double i = 42.1;
std::cout << "max(7,i):   " << ::max(7,i) << std::endl;

返回值是T1,所以返回是int类型,结果是42,出错了

定义3个参数,第3个参数用于表示返回值类型

template <typename T1,typename T2,typename T3>
inline T3 const& max (T1 const& a, T2 const& b)
{
    // if a < b then use b else use a
    return  a < b ? b : a;
}

测试

double i = 42.1;
std::cout << "max(7,i):   " << ::max<int,double,double>(7,i) << std::endl;

返回正确的42.1

5.模板函数重载

// maximum of two int values
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()
{
    ::max(7, 42, 68);     // calls the template for three arguments
    ::max(7.0, 42.0);     // calls max<double> (by argument deduction)
    ::max('a', 'b');      // calls max<char> (by argument deduction)
    ::max(7, 42);         // calls the nontemplate for two ints
    ::max<>(7, 42);       // calls max<int> (by argument deduction)
    ::max<double>(7, 42); // calls max<double> (no argument deduction)
    ::max('a', 42.7);     // calls the nontemplate for two ints
}

特别注意::max<>(7, 42);这句的写法 
注意:自动类型转换

::max('a', 42.7); 只适用于常规函数,'a’会完成自动类型转换

6.字符串重载的例子

#include <iostream>
#include <cstring>
#include <string>

// 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 two pointers
template <typename T>
inline T* const& max (T* const& a, T* const& b)
{
    return  *a < *b  ?  b : a;
}

// maximum of two C-strings
inline char const* const& max (char const* const& a,
                               char const* const& b)
{ 
    return  std::strcmp(a,b) < 0  ?  b : a;
}

int main ()
{
    int a=7;
    int b=42;
    ::max(a,b);      // max() for two values of type int

    std::string s="hey";
    std::string t="you";
    ::max(s,t);      // max() for two values of type std::string

    int* p1 = &b;
    int* p2 = &a;
    ::max(p1,p2);    // max() for two pointers

    char const* s1 = "David";
    char const* s2 = "Nico";
    ::max(s1,s2);    // max() for two C-strings
}

注意每个重载函数必须存在着一定的差异.

7.总是把重载函数定义在调用之前

// 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);  // uses the template version even for ints
}                              // because the following declaration comes
                               // too late:
// maximum of two int values
inline int const& max (int const& a, int const& b) 
{
    return  a < b ? b : a;
}

3参数的max调用的是2参数模板函数,而非最后定义的max非模板函数

8.std:string和char

#include <string>

// note: reference parameters
template <typename T>
inline T const& max (T const& a, T const& b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}

“apple”会被转成 char[6]数组,所以比较要求数组维度长度相同,第二条”tomato”与”apple”长度不符合,即出错.

s是std:: string类型,而非char数组,所以也出错

9.以非引用参数方式传递

#include <string>

// note: nonreference parameters
template <typename T>
inline T max (T a, T b)
{
    return  a < b  ?  b : a;
}

int main()
{
    std::string s;

    ::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // OK: decays to same type
    ::max("apple",s);         // ERROR: different types
}

只有最后类型不符合的编译不通过

C++ STL学习笔记 : 1. template 模板函数
Cy_coding的博客
04-25 412
本篇文章是学习C++ STL库的第一篇笔记，主要记录了使用template关键字创建模板函数的方法。 下面用一个非常简单的例子解释模板函数的用法 : #include <iostream> using namespace std; template <class T> void myswap(T& a, T& b) { T temp = a; ...
Modern C++ 学习笔记——C++函数式编程
小小笑笑川的博客
07-13 3732
C++函数式编程看这一篇就够了，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
C++函数模板template
piyixia的博客
07-17 271
#include<iostream> using namespace std; template<typename T> T max(T a, T b, T c) { if (b > a)a = b; if (c > a)a = c; return a; } int main() { int i1 = 10, i2 = 20, i...
c++函数模板
heizistudio的专栏
07-22 663
#include using namespace std; template T max(T a,T b,T c) {  if(b>a) a=b;  if(c>a) a=c;  return a; }  int main() {   int i1=185,i2=-76,i3=567,i;   double d1=56.63,d2=90.23,d3=-3214.78,d;
函数模板
jinyexingchenwuxin的专栏
05-13 268
<br />#include<iostream><br />using namespace std;<br />template<typename T><br />T max(T a,T b,T c)<br />{<br /> if(b>a) a=b;<br /> if(c>a) a=c;<br /> return a;<br />}<br />int main()<br />{<br /> int i1=23,i2=34,i3=32,i;<br /> double f1=2.3,f2=4.5,f3=2.4
C++函数模板（Function Template）
akjw008的专栏
05-18 632
C++函数模板（Function Template） C语言中文网推出辅导班啦，包括「C语言辅导班、C++辅导班、算法/数据结构辅导班」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践 + 永久学习。QQ在线，随时响应！ 在《C++函数重载》一节中，为了交换不同类型的变量的值，我们通过函数重载定义了四个名字相同、参数列表不同的函数，如下所示： //交换 int 变量的值 void Swap(int *a, int *b){ int temp = *a; *.
C++学习笔记--函数
09-08
**C++学习笔记--函数** 在C++编程中，函数是一种可重用的代码块，它执行特定的任务并可能接收参数、返回值或两者都有。本笔记将深入探讨C++中的函数，包括它们的定义、调用、参数传递以及如何在实际编程中有效地...
C++学习笔记——模板
最新发布
不想随波逐流的大学生一枚，我们每个人都在努力奔跑
07-24 1277
总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建。函数模板的作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个。总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板。总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp。总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别。1、如果函数模板和普通函数都可以实现，优先调用普通函数。总结：类模板中成员函数类外实现时，需要加上模板参数列表。
c++学习笔记3_函数模板的使用并实现自己定义的队列
zxm_的博客
09-04 961
template
PTA C++模板练习：利用函数模板，求若个类型数中的最大值
qq_45817366的博客
11-10 2689
7-5 利用函数模板，求若个类型数中的最大值 (50分) 要求设计一个函数模板： template<class T> T Max(T x[],int len) 可以对int、float、Time（时间类）和Date（日期类）或其他基本类型的数据求最大值。 主函数有如下数据成员： int intArray[100]; double douArray[100]; Time timeArray[100]; date dateArray[100]; 【提示】：定义时间类：Time，其含有三个数
C/C++学习笔记(2)--函数模板template<typename T>,类模板详解(1)
maweifei的博客
04-23 4921
(一)函数模板的概念 1--假设要编写一个函数对两个参数求和。实际编程中,我们可能希望定义几个这样的函数,每一个都可以对一种 给定类型的值求和,那么,可能自然会想到使用重载函数.例如: int add(int a,int b) { return a+b; } double add(double a,double b) {
【C++】模板之函数模板
qq_43411563的博客
05-25 613
一、函数模板的引出 1、如果现在要求写个代码实现两个数相加。我们一般的做法是： int Sum(int a, int b) { return a+b; } 这段代码是有类型限制的，如果浮点数相加的话就得不到我们预期的结果。 2、那我们怎么能写一段代码实现两个数相加并且和类型无关，任何类型都通用呢？ （1）首先我们可以用宏处理 #define Sum(a,b) a + b int main() { int a = 10; int b = 20; int c = 0; c = Sum(a,b);
template class T 什么意思
热门推荐
Wind_bow的博客
07-24 1万+
不多说，直接上代码 #include&lt;bits/stdc++.h&gt; using namespace std; template &lt; class T &gt;//template &lt; typename T &gt; T mmm( T a, T b ) { return a &lt; b ? b : a; } //在这就相当于一种类型 int main() { int x=...
C++之函数模板
hpu_zhn的博客
12-20 557
内容敬请期待
C++：函数模板示例
qq_41708281的博客
05-05 277
//functionTemplate.h //定义函数模板 template <typename T> T Max(T a, T b) { return a > b ? a : b; } // Function_muban.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include"funtionTemplate.h" #include <iostream> using namespace std; int _tmai..
C++之函数模板详解(二)
Bruce_0712的博客
05-22 753
在《C++函数重载》一节中，为了交换不同类型的变量的值，我们通过函数重载定义了四个名字相同、参数列表不同的函数，如下所示： //交换 int 变量的值void Swap(int *a, int *b){ int temp = *a; *a = *b; *b = temp;} //交换 float 变量的值void Swap(float *a, float *b){
C++模板
qq_46191536的博客
05-12 250
模板能够减少重复代码的编写，方便程序的编写，简化内容。 模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。算法也是一种模板，就是提供了解决的方法和思路，但是并不局限于对象的类型。 函数模板 当我们对多种数据（例如int，float）实行同一个功能时，我们可以使用到模板，这样就能省去重复编写代码，来改变变量类型的麻烦。一个模板能进行多种数据类型的输入。 基础的定义如下 template <typename T> 函数定义 下面是一个通过模板，来实现同一函数输入，输出不同数
C++学习笔记：重载函数调用运算符详解
"这篇文档是关于C++学习的笔记，主要讲解了重载函数调用运算符的概念和应用。文章提到了重载函数调用运算符`()`在C++中的特性，包括它必须返回对象的引用以便用作左值，需要至少一个形式参数，并且只能用成员函数来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值