C++模板

最新推荐文章于 2024-01-19 03:00:00 发布
最新推荐文章于 2024-01-19 03:00:00 发布
阅读量429 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010126059/article/details/48421281
版权

一、模板的起源

1.C/C++语言的静态类型系统，在满足效率与安全性要求的同时，很大程度上也成为阻碍程序员编写通用代码的桎梏。它迫使人们不得不为每一种数据类型编写完全或几乎完全相同的实现，虽然它们在抽象层面上是一致的。
2.宏定义只是在预处理器的作用下，针对源代码的文本替换，其本身并不具备函数语义。因此借助于参数宏（又名宏函数）可以在某种程度上是程序的编写者摆脱那些源于类型的约束和限制，但同时也因此丧失了类型的安全性。
#include <iostream>
using namespace std;
#define max(x, y) ((x) < (y) ? (y) : (x))
int main (void) {
    int a = 123, b = 456;
    cout << max (a, b) << endl; // 456
    double c = 1.23, d = 4.56;
    cout << max (c, d) << endl; // 4.56
    string e = "hello", f = "world";
    cout << max (e, f) << endl; // world
    char g[] = "hello", h[] = "world";
    cout << max (g, h) << endl;
    return 0;
}
3.利用宏定义构建通用代码框架，让预处理器将其扩展为针对不同类型的具体函数。将将宏的一般性和函数的类型安全性完美地结合起来。
#include <iostream>
using namespace std;
#define MAX(T) \
T max_##T (T x, T y) { \
    return x < y ? y : x; \
}
MAX (int) // int max_int (int x, int y) { ... }
MAX (double)
MAX (string)
#define max(T) max_##T
int main (void) {
    int a = 123, b = 456;
    cout << max(int) (a, b) << endl;
//  cout << max_int (a, b) << endl;
    double c = 1.23, d = 4.56;
    cout << max(double) (c, d) << endl;
    string e = "hello", f = "world";
    cout << max(string) (e, f) << endl;
    char g[] = "hello", h[] = "world";
    cout << max(string) (g, h) << endl;
    return 0;
}

二、函数模板

1.函数模板的定义
template<typename A, typename b, typename _C>
A function (b arg) {
    _C bar;
    ...
}
2.函数模板的使用
int x = function<int, double, string> (3.14);
3.模板实例化

通常而言，并是不把模板编译成一个可以处理任何类型的单一实体，而是对于实例化模板参数的每种类型，都从模板产生出一个不同的实体。这种用具体类型代替模板参数的过程叫做实例化。它所产生的具体函数就是该模板的一个实例。

4.二次编译

与普通函数不同，模板函数要被编译两次：
第一次编译：与类型参数无关的语法检查、生成该模板的内部表示；
第二次编译：用实例化语句中的类型实参与该模板的内部表示结合，做与类型参数相关的语法检查、生成针对具体函数的二进制指令代码。

5.隐式推断

如果函数模板调用参数的类型与该模板的类型参数相关，那么在调用该函数模板时，即使不显式指定模板参数，编译器也有能力根据调用参数的类型隐式推断出模板参数的具体类型，以获得与普通函数调用一致的语法形式。

#include <cstdlib>
#include <iostream>
#include <typeinfo>
using namespace std;
template<typename T>
void foo (T const& x, T const& y) {
    cout << typeid (x).name () << ' '
        << typeid (y).name () << endl;
}
template<typename T>
void bar (T x, T y) {
    cout << typeid (x).name () << ' '
        << typeid (y).name () << endl;
}
template<typename R, typename T>
//template<typename T, typename R> // 错误
R hum (T const& x) {
    R y;
    cout << typeid (x).name () << ' '
        << typeid (y).name () << endl;
    return y;
}
int main (void) {
    int a, b;
    foo (a, b); // i i
    double c, d;
    foo (c, d); // d d
    char e[256], f[256];
    foo (e, f); // A256_c A256_c
    bar (e, f); // Pc Pc
    foo ("hello", "world"); // A6_c A6_c
    bar ("hello", "world"); // PKc PKc
//  foo ("hello", "tarena");// 错误
    bar ("hello", "tarena");// PKc PKc
    foo (string ("hello"), string ("tarena"));
    // Ss Ss
//  foo (a, c); // 错误，隐式推断不能同时隐式转换
    // i i X
    // d d X
    // i d X
    // d i X
    foo ((double)a, c); // d d
    foo (a, (int)c); // i i
    foo<double> (a, c); // d d
    foo<int> (a, c); // i i
    int g;
    double h;
//  g = hum (h); // 错误，返回类型不参与隐式推断
    g = hum<int, double> (h); // d i
    g = hum<int> (h); // d i
    return 0;
}
tips:要注意编译器所推断出的类型不一定和程序编写者所期望的类型一致。
6.重载

函数模板和函数模板，以及函数模板和普通函数，都可以构成重载关系。

#include <cstdlib>
#include <cstring>
#include <iostream>
#include <typeinfo>
using namespace std;
// 两个任意类型对象的最大值
template<typename T>
T const& max (T const& x, T const& y) {
    cout << "<1" << typeid (x).name () << '>'
        << flush;
    return x < y ? y : x;
}
// 两个任意类型指针所指向目标的最大值
template<typename T>
T* const& max (T* const& x, T* const& y) {
    cout << "<2" << typeid (x).name () << '>'
        << flush;
    return *x < *y ? y : x;
}
// 两个C风格字符串的最大值
// 在重载函数模板的时候，应该尽可能将改变限制在参数
// 的个数或具体类型上，否则极可能导致非预期的后果
char const* const& max (char const* const& x,
    char const* const& y) {
    cout << "<3" << typeid (x).name () << '>'
        << flush;
    return strcmp (x, y) < 0 ? y : x;
}
/*
char const* max (char const* x, char const* y) {
    return strcmp (x, y) < 0 ? y : x;
}*/
// 三个任意类型对象的最大值
template<typename T>
T const& max (T const& x, T const& y, T const& z) {
    cout << "<4" << typeid (x).name () << '>'
        << flush;
    // 重载解析是在函数模板第二次编译阶段进行的，因
    // 此即使是在函数模板内部，同样优先选择普通函数
    // 重载解析的候选范围在第一次编译的时候确定，因
    // 此必须保证所有可供选择的重载版本在函数模板被
    // 第一次编译时可见
    return ::max (::max (x, y), z);
}
/*
char const* const& max (char const* const& x,
    char const* const& y) {
    cout << "<3" << typeid (x).name () << '>'
        << flush;
    return strcmp (x, y) < 0 ? y : x;
}*/
int main (void) {
    char const* x = "abc"; // 大
    char const* y = "ab";  // 中
    char const* z = "a";   // 小
    // 编译器优先选择普通函数
    cout << ::max (x, y) << endl; // 3
    // 除非函数模板能够产生具有更好匹配性的函数
    cout << ::max (123, 456) << endl; // 1
    // 通过模板参数表的左右尖括号显式表明需要调用函
    // 数模板，针对指针的版本比任意类型的版本更具体
    cout << ::max<> (y, x) << endl; // 2
    // 显式指定的模板参数必须在所选择的重载版本中与
    // 调用参数的类型保持一致
    cout << ::max<char const*> (y, z) << endl; // 1
    const char* const& res = ::max (x, y, z);
    cout << res << endl; // 4
    char const* a = "123";
    char const* b = "12";
    char const* c = "1";
    ::max (a, b, c);
    cout << res << endl;
    return 0;
}

三、类模板

1.类模板的定义
template<typename A, typename b, typename _C>
class MyClass : b {
public:
    A m_a;
    void foo (_C c) { ... }
};
2.类模板的使用
MyClass<int, Human, string> obj;
3.两步实例化
      编译期           运行期
类模板 -实例化-> 类 -实例化-> 对象
tips
:1)类模板中，只有那些被调用的成员函数才会被实例化，即产生实例化代码。某些类型虽然并没有提供类模板所需要的全部功能，但照样可以实例化该类模板，只要不直接或间接调用那些依赖于未提供功能的成员函数即可。
2)类模板必须显式实例化，不支持隐式推断。
3)类模板本身不代表一个类型，不能用于声明对象、引用或者指针，只有通过类型参数将其实例化为具体类以后，才可以作为类型用于对象、引用或者指针的声明。
4)类模板静态成员变量既不是一个模板一份实例，也不是一个对象一份实例，而是该类模板的每个实例化类中都有一份独立的实例，且为该实例化类所创建的所有对象所共享。
4.模板的特例化
一个类模板的通用版本可能对某些特殊类型并不适用，或者不够优化，这时候可以定义该类模板或其中某些成员函数针对此类型的特殊实现，谓之特例化。

1)全类特化：将整个类模板重写成针对某种具体类型的具体类。

template<>
class 类模板名<所针对的具体类型> { 具体类的实现 };

2)成员特化：将类模板中的某些与具体类型相关的成员函数，单独进行特化。
template<>
返回类型 类模板名<所针对的具体类型>::成员函数名 (形参表) { 具体实现 }

#include <cstring>
#include <iostream>
using namespace std;
template<typename T>
T max (T x, T y) {
    return x < y ? y : x;
}
char const* max (char const* x, char const* y) {
    return strcmp (x, y) < 0 ? y : x;
}
// 通用版本
template<typename T>
class Comparator {
public:
    Comparator (T x, T y) : m_x (x), m_y (y) {}
    T max (void) const {
        return m_x < m_y ? m_y : m_x;
    }
    /*
    char const* max (void) const {
        return strcmp (m_x, m_y) < 0 ? m_y : m_x;
    }*/
private:
    T m_x, m_y;
};
/*
// 针对char const*类型的全类特化版本
template<>
class Comparator<char const*> {
public:
    Comparator (char const* x, char const* y) :
        m_x (x), m_y (y) {}
    char const* max (void) const {
        return strcmp (m_x, m_y) < 0 ? m_y : m_x;
    }
private:
    char const* m_x, *m_y;
};
*/
// 针对char const*类型的成员特化版本
template<>
char const* Comparator<char const*>::max (
    void) const {
    return strcmp (m_x, m_y) < 0 ? m_y : m_x;
}
template<typename T>
class A {
public:
    static void foo (void) {
        cout << "A<T>" << endl;
    }
    static T hum (T t) {
        return t;
    }
};
template<>//A的全类特化
class A<int> {
public:
    static void bar (int x, int y) {
        cout << "A<int> " << x << ' ' << y
           << endl;
    }
};
template<> //对类A的成员特化
void A<string>::foo (/*int*/void) {
    cout << "A<string>" << endl;
}
template<>//对类A的成员特化
string A<string>::hum (string t) /*throw ()*/ {
    cout << "A<string>::hum(string)" << endl;
    return t;
}
int main (void) {
    cout << ::max (123, 456) << endl;
    cout << ::max ("hello", "world") << endl;
    /*
    cout << ::max<string> ("hello", "world")
        << endl;
    cout << ::max (string ("hello"),
            string ("world")) << endl;
    */
    cout << Comparator<int> (123, 456).max ()
        << endl;
    cout << Comparator<char const*> ("hello",
        "world").max () << endl;
    A<double>::foo ();
    A<int>::bar (123, 456);
    A<string>::foo ();
    A<string>::hum ("abc");
    return 0;
}
tips:成员特化的声明为通用版本和特化版本所共享，因此特化实现除了类型参数以外的接口规格(返回类型、函数名、形参表、常属性、异常说明)必须和通用版本完全一致。
3)局部特化(偏特化)

定义一个关于类模板的特化实现，该实现只针对该模板部分类型参数取特定类型，或者类型参数之间具有某种特定关系或属性。

#include <iostream>
using namespace std;
template<typename A, typename B>
class X {
public:
    static void foo (void) {
        cout << "X<A,B>" << endl;
    }
};
template<typename A> //X的局部特化
class X<A, short> {  
public:
    static void foo (void) {
        cout << "X<A,short>" << endl;
    }
};
template<>
void X<int, double>::foo (void) {  
    cout << "X<int,double>::foo" << endl;
}
/*
// 局部特化不能只针对成员函数进行，
// 而必须针对整个类模板
template<typename A>
void X<A, double>::foo (void) {
    cout << "X<A,double>::foo" << endl;
}*/
template<typename A>
class X<A, A> {
public:
    static void foo (void) {
        cout << "X<A,A>" << endl;
    }
};
template<typename A, typename B>
class X<A*, B*> {
public:
    static void foo (void) {
        cout << "X<A*,B*>" << endl;
    }
};
template<typename A>
class X<A*, A*> {
public:
    static void foo (void) {
        cout << "X<A*,A*>" << endl;
    }
};
template<typename A, typename B>
class X<A&, B&> {
public:
    static void foo (void) {
        cout << "X<A&,B&>" << endl;
    }
};
template<typename A, typename B>
class X<A[], B[]> {
public:
    static void foo (void) {
        cout << "X<A[],B[]>" << endl;
    }
};
template<typename A, typename B> //函数模板
void foo (void) {
    cout << "foo<A,B>" << endl;
}
template<>      //函数模板的全特化
void foo<int, short> (void) {
    cout << "foo<int,short>" << endl;
}
/*
// 函数模板只能做完全特化，不能做局部特化
template<typename A>
void foo<A, short> (void) {
    cout << "foo<A,short>" << endl;
}
*/
int main (void) {
    X<int, double>::foo ();
    X<int, short>::foo ();
    X<int, int>::foo ();
    X<int*, short*>::foo ();
    X<int*, int*>::foo ();
    X<int&, short&>::foo ();
    X<int[], short[]>::foo ();
    foo<char, double> ();
    foo<int, short> ();
//  foo<char, short> ();
    return 0;
}
// 全类特化既可以是完全特化，也可以是局部特化
// 成员特化只可能是完全特化，不可能是局部特化

四、模板的缺省参数

类模板的模板参数可以带有缺省值，实例化该模板时，如果没有提供模板实参，则相应的模板形参取缺省值。
#include <iostream>
#include <typeinfo>
using namespace std;
template<typename A = char, typename B = int,
    typename C = double>
class X {
public:
    X (A const& a, B const& b, C const& c) :
       m_a (a), m_b (b), m_c (c) {}
    void foo (void) const {
        cout << typeid (m_a).name () << ": "
            << m_a << endl;
        cout << typeid (m_b).name () << ": "
            << m_b << endl;
        cout << typeid (m_c).name () << ": "
            << m_c << endl;
    }   
private:
    A m_a;
    B m_b;
    C m_c;
};
template<typename A = char, typename B = int,
    typename C = double>
void foo (A const& a, B const& b, C const& c) {
    cout << typeid (a).name () << ": " << a << endl;
    cout << typeid (b).name () << ": " << b << endl;
    cout << typeid (c).name () << ": " << c << endl;
}
/*
void bar (int x, int y = x) {
    cout << x << ' ' << y << endl;
}
*/
template<typename A, typename B = A>
void bar (void) {
    cout << typeid (A).name () << ' '
        << typeid (B).name () << endl;
}
int main (void) {
    X<char, int, double> x1 ('A', 123, 4.56);
    x1.foo ();
    X<char, int> x2 ('A', 123, 4.56);
    x2.foo ();
    X<char> x3 ('A', 123, 4.56);
    x3.foo ();
    X<> x4 ('A', 123, 4.56);
    x4.foo ();
    cout << "-------" << endl;
    foo<char, int, double> ('A', 123, 4.56);
    foo<char, int> ('A', 123, 4.56);
    foo<char> ('A', 123, 4.56);
    foo<> ('A', 123, 4.56);
    foo (4.56, 123, 'A');
//  缺省参数：A/B/C -> char/int/double
//  隐式推断：A/B/C -> double/int/char <- 以此为准
//  bar (100);
    bar<string> ();
    return 0;
}
tips:

1).如果某个模板参数带有缺省值，那么它后面的所有模板参数必须都带有缺省值。
2).函数模板在C++2011标准以前不能带有缺省参数，但在该标准以后可以，其作用与类模板一致。
3).对于函数模板的类型参数，当隐式推断的结果与该参数的缺省值不一致时，以隐式推断为准。
4)函数模板的调用参数(圆括号中的参数)无论是98标准还是11标准都可以带有缺省值。
5)可以用前面的模板参数作为后面的模板参数的缺省值。

五、模板的非类型参数

1.模板的参数除了类型参数以外，也可以是数值形式的参数，与类型参数不同，模板的非类型参数不能用typename关键字声明，而必须使用具体类型，如int、unsigned int等。
2.传递给模板的非类型参数的实参只能是常量、常量表达式、带有常属性(const)的变量，但是不能同时带有挥发性(volatile)。
3.编译器的实现对模板非类型参数的限制
1)模板的非类型参数不能是浮点形式的。
2)模板的非类型参数不能是类类型的。
3)如果希望向模板传递字符串形式的非类型参数，其形参只能使用指针而不能是string，因为string是类类型，而且所传递的实参必须是没有static特性的全局字符数组。

include <iostream>
using namespace std;
class Integer {
public:
    Integer (int i) : m_i (i) {};
    int m_i;
};
ostream& operator<< (ostream& os,
    Integer const& i) {
    return os << i.m_i;
}
template<int/*double*//*float*//*Integer*/ x>
int/*double*//*float*//*Integer*/ square (void) {
    return x * x/*Integer (x.m_i * x.m_i)*/;
}
template</*string*/char const* s>
void foo (void) {
    cout << s << endl;
}
//char const* global = "abc";
/*static*/char array[] = "abc";
int main (void) {
    cout << square<4/*4.0*//*4.0f*/
        /*Integer (4)*/> () << endl;
//  char const* local = "abc";
//  char array[] = "abc";
    foo</*"abc"*//*local*/array/*global*/> ();
    return 0;
}

六、模板关键字的其它语义

1)typename解决嵌套依赖——访问依赖于模板参数的类型的内部类型。
在第一次编译模板代码时，模板参数的具体类型尚不明确，编译器会把依赖于模板参数的嵌套(内部)类型理解为某个类的静态成员变量。因此当它看到代码中使用这样的标识符声明其它变量时，会报告错误。typename关键字可以告诉编译器，所引用的标识符是个类型名，可以声明变量，具体类型等到实例化该模板(第二次编译)时再确定。
struct \
class - 声明类
\ 声明模板的
/ 类型参数

#include <iostream>
using namespace std;
class A {
public:
    typedef unsigned int UINT;
    class B {};
};
template<typename T>
void foo (void) {
    typename T::UINT u;
    typename T::B b;
}
int main (void) {
    A::UINT u;
    A::B b;
    foo<A> ();
    return 0;
}

2)template访问依赖于模板参数的模板型成员。
在模板代码中，通过依赖于模板参数的对象、引用或指针，访问其带有模板特性的成员，编译器常常因为无法正确理解模板参数列表的左右尖括号，而报告错误。在所引用模板名前面加上template关键字，意在告诉编译器其后的名称是一个模板，编译器就可以正确理解”<>”了。 

#include <iostream>
#include <typeinfo>
using namespace std;
class A {
public:
    // 模板型成员函数
    template<typename T>
    void foo (T t) const {
        cout << "A::foo(" << typeid (t).name ()
            << ")" << endl;
    }
};
template<typename T>
void bar (T const& t) {
    t.template foo<string> ("1");
    T const* p = &t;
    p->template foo<string> ("1");
}
int main (void) {
    A a;
    a.foo (123);
    a.foo (1.2);
    a.foo ('1');
    a.foo ("1");
    a.foo<string> ("1");
    bar (a);
    return 0;
}

七、从模板形式基类中继承

1.如果基类是模板，那么子类必须也是模板，基类的模板参数通过子类的模板参数传递。
2.在子类模板中访问从基类模板中继承的成员，需要通过作用限定或者this指针显式指明，否则编译器只会在子类的作用域和全局作用域查找所引用的标识符。

#include <cstdlib>
#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    int m_var;         // 成员变量
    void fun (void) {} // 成员函数
    class B {};        // 成员类型
    void exit (int status) {
        cout << "再见！" << endl;
    }
};
template<typename T>
class C : public A<T> {
public:
    void foo (void) {
//      A<T>::m_var = 100;
        this->m_var = 100;
//      A<T>::fun ();
        this->fun ();
        typename A<T>::B b;
        A<T>::exit (0);
    }
};
int main (void) {
    C<int> c;
    c.A<int>::m_var = 200;
    c.A<int>::fun ();
    C<int>::B b;
    c.foo ();
    return 0;
}

八、类模板的模板型成员

1.模板型成员变量

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    A (T const& t) : m_t (t) {}
    T m_t;
};
template<typename T>
class B {
public:
    B (T const& t) : m_a (t) {}
    A<T> m_a; // 模板型成员变量
};
int main (void) {
    B<int> b (100);
    cout << b.m_a.m_t << endl;
    span class="hljs-keyword">return 0;
}

2.模板型成员函数

#include <iostream>
using namespace std;
template<typename A>
class X {
public:
    X (A const& a) : m_a (a) {}
    // 模板型成员函数
    /*
    template<typename B>
    void foo (B const& b) const {
        cout << m_a << ' ' << b << endl;
    }*/
    template<typename B>
    void foo (B const& b) const;
private:
    A m_a;
};
template<typename A>
    template<typename B>
void X<A>::foo (B const& b) const {
    cout << m_a << ' ' << b << endl;
}
int main (void) {
    X<int> x (123);
    x.foo (4.56);
    return 0;
}

3.模板型成员类型

#include <iostream>
using namespace std;
template<typename A>
class X {
public:
    X (A const& a) : m_a (a) {}
    A m_a;
    // 模板型成员类型(类模板的内部类模板)
    /*
    template<typename B>
    class Y {
    public:
        Y (B const& b) : m_b (b) {}
        B m_b;
    };
    */
    template<typename B>
    class Y;
};
template<typename A>
    template<typename B>
class X<A>::Y {
public:
    Y (B const& b) : m_b (b) {}
    B m_b;
};
int main (void) {
    X<int> x (123);
    cout << x.m_a << endl; // 123
    X<int>::Y<double> y (4.56);
    cout << y.m_b << endl; // 4.56
    cout << sizeof (x) << ' ' << sizeof (y)
        << endl; // 4 8
    return 0;

九、模板型模板参数

template<T> class Array { ... };
template<T> class List { ... };
template<T, template<typename> class C = List>
class Stack {
public:
     void push (T const& data) {
         m_c.push_back (data);
     }
     void pop (void) {
         m_c.pop_back ();
     }
     T& top (void) {
         return m_c.back ();
     }
     T const& top (void) const {
         return const_cast<Stack*> (this)->top ();
     }
private:
     C<T> m_c;
};
Stack<int, Array> sia;
Stack<string, List> ssl;
Stack<double> sdl;

十、零初始化

类型参数 对象 = 类型参数 ();
如：T t = T ();
如果用类类型实例化模板参数T，则用该类的缺省构造函数初始化t；
如果用基本类型实例化模板参数T，则用相应类型的0初始化t。

#include <iostream>
using namespace std;
template<typename T>
void foo (void) {
    T t = T (); // 零初始化语法
//  int t = int ();
//  string t = string ();
//  Student t = Student ();
    cout << '[' << t << ']' << endl;
}
template<typename T>
class A {
public:
    A (void) : m_t () { /*m_t = T ();*/ }
    T m_t;
};
class Student {
public:
    Student (string const& name = "学生",
        int age = 20) : m_name (name), m_age (age){}
    friend ostream& operator<< (ostream& os,
        Student const& student) {
        return os << student.m_name << ','
            << student.m_age;
    }
private:
    string m_name;
    int m_age;
};
int main (void) {
    foo<int> ();
    foo<string> ();
    foo<Student> ();
    A<int> ai;
    cout << '[' << ai.m_t << ']' << endl;
    A<string> as;
    cout << '[' << as.m_t << ']' << endl;
    A<Student> at;
    cout << '[' << at.m_t << ']' << endl;
    return 0;
}

十一、类模板与虚函数

1.类模板中可以定义虚函数，只要保证其实例化类满足虚函数覆盖的条件，同样可以表现出多态特性。
2.虚函数本身不能又是模板函数。

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    virtual void foo (T const& t) const {
        cout << "A::foo: " << t << endl;
    }
};
template<typename U, typename T>
class B : public A<U> {
public:
    void foo (T const& t) const {
        cout << "B::foo: " << t << endl;
    }
};
/*
class C {
public:
    template<typename T>
    virtual void foo (T const& t) const {
        cout << "C::foo: " << t << endl;
    }
};*/
int main (void) {
    B<int, int> b1;
    A<int>& a1 = b1;
    a1.foo (123);         //123
    B<int, double> b2;
    A<int>& a2 = b2;
    a2.foo (4.56);  //4
    return 0;
}
JeremiahSu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 模板函数
01-07
C++模板的使用可以提升代码的通用性、可移植性。方便通用库的开发。 与模板有关的关键字有两个： template 定义模板所用到的关键字。 typename 类型的名字，比如int，double，可以使用类类型，struck类型等。也可以...
C++模板元编程
01-06
C++模板元编程
【C++学习笔记】1.2 C++输入与输出
kikokingの比特宇宙
07-28 729
C++的输入输出操作相比C语言更加方便，它不需要像printf/scanf那样手动设置格式，C++ 的输入输出可以自动识别变量类型。
用C++语言实现Python的input()函数
brCreate的博客
11-26 1215
如何用C++实现Python的内建函数input()，参数、回传值完全一样？
C++自制函数分享:input
最新发布
zhuo_yue_shi的博客
01-19 584
提供了一种方便于输入的函数
C/C++字符输入函数(详解)
MelyLenient的博客
04-06 4454
文章目录C/C++字符输入函数(详解)1.常用函数(scanf函数)2.cin流控输入3. gets()函数4.getline()函数5.cin.get (char *str, int maxnum)特殊输入函数1> sprintf():2> sscanf():上章题解：问题：通过灵活输入原字符串，需要替换的字符换，需要被替换的字符串，并输出结果。 C/C++字符输入函数(详解) C/C++实现从终端（包括但不限于键盘，对于嵌入式设备可以是网口/串口）。 C/C++所提供的标准库提供了不下于一
C++输入输出（新手教程）
this_id_is_full的博客
10-06 1253
在C++中，输入和输出是非常重要的。在洛谷中，几乎每到题都需要用到输入输出。这篇文章就是简单的给大家介绍了输入输出。
c++模板详细描述
01-05
c++模板详细描述
C++模板 第二版中文版
03-17
在第一版的基础上进行了大量修订，并介绍了部分语言新特性，C++11
由浅入深学习C++模板
11-21
模板练习 ├─Macro1 │ └─res ├─Macro2 │ └─res ├─Macro3 │ └─res ├─Template1 ├─Template2 ├─Template3 ├─Template4 ├─Template5 ├─函数指针模板 │ ├─FuncTemplate1 │ ├─...
详解C++ 模板编程
12-16
类型模板包括函数模板和类模板，基本上是C++开发人员接触模板编程的起点。 下面代码演示了函数模板和类模板的使用方法： // 函数模板 template T add(const T& a, const T& b) { return a + b; } // 类模板 ...
C++模板详解
07-09
主要介绍了C++模板的详细介绍，欢迎大家下载学习啦啦啦啦
C++模板与STL库介绍
03-18
C++模板与STL库介绍 非常详细
如何理解c++模板
05-17
对类模板比较系统的讲解
C++模板专题.pdf
05-03
介绍C++编程语言中，模板相关的理论介绍，原理设计，代码设计技巧等
如何在C++用Python的input和print？
a4364634611的博客
04-18 1849
在C++使用Python的print与input..
C/C++学习笔记十二 Input and Output (I/O)（1）
学以致用 知行合一
05-28 926
输入和输出功能并未定义为核心 C++ 语言的一部分，而是通过 C++ 标准库提供（因此位于 std 命名空间中）。 包含iostream 库头文件并使用 cin 和 cout 对象来执行简单的 I/O。 istream 包含许多其他功能和上述功能的变体，它们可能有用，具体取决于您需要做什么。
C++输入函数用法
qq_41941017的博客
03-20 1556
c++输入函数用法 1、cin>> 用法1：最基本，也是最常用的用法，输入一个数字： #include using namespace std; main () { int a,b; cin>>a>>b; cout<<a+b<<endl; } 输入：2[回车]3[回车] 输出：5 注意:>> 是会过滤掉不可见字符（如 空格 ...
input 函数的使用
qq_64470623的博客
03-11 1196
python基础-----input输入函数

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值