template<typename T> T add(const T&a, const T &b) { return a+b; } void func(int(*ptrfun)(const int& a, const int& b)) //后面两个参数的声明必须写 { cout<<"int"<<endl; } void func(string(*ptrfun)(const string& a,const string& b)) { cout<<"string"<<endl; } void main() { func(add<int>); }
#include <iostream> template<typename T0, typename T1, typename T2, typename T3, typename T4> T2 func(T1 v1, T3 v3, T4 v4); int main() { double sv2; using namespace std; sv2 = func<double, int, int>(1, 2, 3); cout << "\tsv2: " << sv2 << endl; sv2 = func<double, int, int>(1, 2, 3); cout << "\tsv2: " << sv2 << endl; sv2 = func<double, int, int>(1, 0.1, 0.1); cout << "\tsv2: " << sv2 << endl; sv2 = func<int, double, double>(0.1, 0.1, 0.1); cout << "\tsv2: " << sv2 << endl; } template<typename T0, typename T1, typename T2, typename T3, typename T4> T2 func(T1 v1, T3 v3, T4 v4) { T0 static sv0 = T0(0); T2 static sv2 = T2(0); std::cout << "\tv1: " << v1 << "\tv3: " << v3 << "\tv4: " << v4 << "\t|| sv0: " << sv0;
T2 v2 = sv2; sv0 -= 1; sv2 -= 1; return v2; }
// 文件名caller1.cpp #include <iostream> template<typename T> void func(T const &v) { std::cout << "func1: " << v << std::endl; } void caller1() { func(1); func(0.1); } // ====================================== // 文件名caller2.cpp #include <iostream> template<typename T> void func(T const &v) { std::cout << "func2: " << v << std::endl; } void caller2() { func(2); func(0.2f); } // ====================================== // 文件名main.cpp void caller1(); void caller2(); int main() { caller1(); caller2(); return 0; }
template<typename T> T add(const T&a, const T &b) { return a+b; } void func(int(*ptrfun)(const int& a, const int& b),const int& a, const int&b) //后面两个参数的声明必须写 { ptrfun=add<int>; cout<<ptrfun(a,b)<<endl; } void func(string(*ptrfun)(const string& a,const string& b),const string& a,const string& b) { ptrfun=add<string>; cout<<ptrfun(a,b)<<endl; } void main() { func(add,1,2); func(add,"hello","world"); }
template<typename T> T add(const T&a, const T &b) { return a+b; } void func(int(*ptrfun)(const int& a, const int& b)) //后面两个参数的声明必须写 { cout<<"int"<<endl; } void func(string(*ptrfun)(const string& a,const string& b)) { cout<<"string"<<endl; } void main() { func(add<int>); }
template<typename T> class my_stack; // 前置栈类模板声明 template<typename T> class list_node { T value; list_node *next; // 私有构造函数,只能由其友类构造 list_node(T const &v, list_node *n) :value(v), next(n) {} // 友类必须是类模板my_stack的实例 friend class my_stack<T>; }; template<typename T=int> class my_stack { private: typedef list_node<T> node_type;//<T>不可省略 node_type *head; // my_stack不可复制构造,也不可赋值 my_stack operator=(my_stack const &) {} my_stack(my_stack const &s) {} public: // 构造与析构 my_stack() : head(0) {} ~my_stack() {while (!empty()) pop();} // 在类模板内实现的成员函数模板 bool empty() const {return head == 0;} T const& top() const { if (empty()) throw std::runtime_error("stack is empty."); return head->value; } void push(T const &v) {head = new node_type(v, head);} // 成员函数声明,将在类模板外实现 void pop(); }; // 在类模板外实现的成员函数模板 template<typename T> void my_stack<T>::pop() { if (head) { node_type *tmp = head; head = head->next; delete tmp; } } //子类模板:计数栈 template<typename T=int> class count_stack : public my_stack<T> { typedef my_stack<T> base_type; // 非常有用的typedef unsigned size; public: count_stack() : base_type(), size(0) {} void push(T const &v) { base_type::push(v); size++; } void pop() { if (size > 0) { base_type::pop(); size--; } } unsigned getSize() const {return size;} };
#include "stack.h" int main() { my_stack<> mystack; mystack.push(2); cout<<mystack.top()<<endl; count_stack<> costack; costack.push(9); costack.push(8); costack.push(7); cout<<costack.getSize()<<endl; return 0; }
struct normal_class { int value; template<typename T> void set(T const &v) {value = int(v);} template<typename T> T get(); }; template<typename T> T normal_class::get() { return T(value); }
template<typename T0> struct a_class_template { T0 value; template<typename T1> void set(T1 const &v){value = T0(v);} template<typename T1> T1 get(); }; // 类模板的成员函数模板在类模板外的实现方法 template<typename T0> template<typename T1> T1 a_class_template<T0>::get() { return T1(value); }
template<typename T> class the_class { public: static int id; the_class() {++id;} static T getid(){return T(id)/2;} }; template<typename T> int the_class<T>::id = 1;
#include "the_class.h" void call() { the_class<int> c; std::cout << c.id << std::endl; }
#include "the_class.h" void call1() { the_class<int> c; std::cout << c.id << std::endl; }
void call(); void call1(); int main() { call(); call1(); }