C++之模板

#include<iostream>
using namespace std;
/*
 * 模板:Templates
 * 泛型(Generic Programming)即是指具有在多种数据类型上皆可操作的含意。泛型编程的代表作品STL是一种高效、泛型、可交互操作的软件组件
 * 泛型编程最初诞生于C++中，目的是为了实现C++的STL(标准模板库)。其语言支持机制就是模板(Templates)。模板的精神其实很简单:参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽调，抽出来做成模板参数T。
 */
#if 0
void Swap(int &a,int &b)
{
    int t=a;
    a=b;
    b=t;
}

void Swap(double &a,double &b)
{
    double t=a;
    a=b;
    b=t;
}

int main()
{
    //把这里换成double也可以换出来
    #if 0
    int a=4;
    int b=5;
    #endif
    //那么问题来了，假设你又来一个long,你又要写个函数，所以模板就说不要那么麻烦了
    double a=4;
    double b=5;
    cout<<a<<b<<endl;
    Swap(a,b);
    cout<<a<<b<<endl;
    return 0;
}
#endif

#if 0
模板的语法
template<typename/class 类型参数表>
返回类型 函数模板名(函数参数列表)
{
    函数模板定义体
}
#endif
//这里不叫函数，叫函数模板，函数模板用来产生函数的，他会根据具体的类型
//产生模板函数，你T=long类型的时候，就是void Swap<long>(a,b) 
//函数模板只用于函数的参数个数相同而类型不同，且函数体相同的情况下，如果个数不同，则不能用函数模板。
template<typename T>
void Swap(T &a,T &b)
{
    cout<<a<<b<<endl;
    T t=a;
    a=b;
    b=t;
    cout<<a<<b<<endl;
}

int main()
{
  long a=4,b=5;
  Swap(a,b);
  double c=3,d=7;
  Swap(c,d);
}

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

using namespace std;
//看下面的代码，下面的代码是典型的数据结构栈，
//数据结构最容易构成模板
//这个Stack有个特点，就是所有的存储类型一致。
//下面的代码不可能一会压int，一会压float的
//所以底层的存储空间类型一致，push进去的东西和底层保持一致
//POP出来的东西跟底层也是一致的。所以对这个东西用模板就非常的方便
//我们看下面的代码，发现底层的数据是在构造器那里决定的。你POP出去的东西就是底层里面的东西，PUSH的东西也是底层里面的东西。所以特别适合用来在做模板。


//一般模板先实例化完之后再套模板，这样一般简单一些。
//没用模板的时候
#if 0
class Stack
{
public:
    Stack(int _i4_size=1024);
    ~Stack();
    bool isEmpty();
    bool isFull();
    void push(int i4_data);
    int pop();
private:
    int *ai4_space;
    int i4_top;
};

Stack::Stack(int _i4_size)
{
    ai4_space =new int[_i4_size];
    i4_top=0;
}

Stack::~Stack()
{
    delete []ai4_space;
}

bool Stack::isEmpty()
{
    return i4_top==0;
}

bool Stack::isFull()
{
    return i4_top==1024;
~Shape()
}

void Stack::push(int _i4_data)
{
    ai4_space[i4_top++]=_i4_data;
}

int Stack::pop()
{
    return ai4_space[--i4_top];
}

int main()
{
    Stack s(100);
    if(!s.isFull())
    s.push(10);
    if(!s.isFull())
    s.push(20);
    if(!s.isFull())
    s.push(30);
    if(!s.isFull())
    s.push(40);
    if(!s.isFull())
    s.push(50);
    while(!s.isEmpty())
    cout<<s.pop()<<endl;
}
#endif


//使用的类不是普通的类，此时的类是个类模板。
//用这个类模板可以生成类对象。它的每个实现元素都要顶着这个template<typename T>
//而且这是个类模板，所以作用域要变成Stack<T>
//但是放到类里面就不用带
template<typename T>
class Stack
{
public:
    Stack(int _i4_size=1024);
    ~Stack();
    bool isEmpty();
    bool isFull();
    void push(T i4_data);
    T pop();
private:
    T *ai4_space;
    int i4_top;
};

template<typename T>
Stack<T>::Stack(int _i4_size)
{
    ai4_space =new T[_i4_size];
    i4_top=0;
}

template<typename T>
Stack<T>::~Stack()
{
    delete []ai4_space;
}

template<typename T>
bool Stack<T>::isEmpty()
{
    return i4_top==0;
}

template<typename T>
bool Stack<T>::isFull()
{
    return i4_top==1024;
}

template<typename T>
void Stack<T>::push(T _i4_data)
{
    ai4_space[i4_top++]=_i4_data;
}

template<typename T>
T Stack<T>::pop()
{
    return ai4_space[--i4_top];
}

int main()
{
#if 0
    Stack s(100);
    if(!s.isFull())
    s.push(10);
    if(!s.isFull())
    s.push(20);
    if(!s.isFull())
    s.push(30);
    if(!s.isFull())
    s.push(40);
    if(!s.isFull())
    s.push(50);
    while(!s.isEmpty())
    cout<<s.pop()<<endl;
#endif

    //先把类模板变成模板类。
    Stack<int> s(100);
    if(!s.isFull())
    s.push(10);
    if(!s.isFull())
    s.push(20);
    if(!s.isFull())
    s.push(30);
    if(!s.isFull())
    s.push(40);
    if(!s.isFull())
    s.push(50);
    while(!s.isEmpty())
    cout<<s.pop()<<endl;


    Stack<string> x(100);
    if(!x.isFull())
    x.push("123");
    if(!x.isFull())
    x.push("234");
    if(!x.isFull())
    x.push("345");
    if(!x.isFull())
    x.push("456");
    if(!x.isFull())
    x.push("567");
    while(!x.isEmpty())
    cout<<x.pop()<<endl;
}