C++ 模板使用

模板是解决重用的一种方式，"模板" 顾名思义，一个框框，框架不会轻易变动，但其中的内容可以随意填写。

以一个栈的定义为例：

class stack
{
private:
enum {ssize = 100};
int m_stack[ssize];
int m_top;
public:
stack() : m_top(0) {m_stack[m_top] = 0;}
void push(int i)
{    if (m_top < ssize) {m_stack[m_top++] = i;};  }

int pop()
{    return stack[m_top > 0 ? --m_top : m_top];  }
}

这个栈最多可以被叫做 int_stack，它只能支持int 类型， 但对与 double 或其他复合类型它就无法满足了。这里的代码也无法被重用。

这时候使用模板就可以很好的解决这个问题。

模板的定义和使用

模板的定义很简单， 使用关键字 template

template <class T>
class stack
{
private:
enum {ssize = 100};
T m_stack[ssize];
int m_top;
public:
stack() : m_top(0) {m_stack[m_top] = 0;}
void push(T i)
{    if (m_top < ssize) {m_stack[m_top++] = i;};  }

T pop()
{    return stack[m_top > 0 ? --m_top : m_top];  }
}

这个类中把int 改为了 T 类型， 这样stack的框框就确定下来了，但其中的内容是可以随意变化的。可以使用double 当然也可以使用复合类型或者是类。

使用 模板类， 模板类被很好的重用了。

#include "stack_t.h"

void main()
{
stack<int> istack;
stack<double> dstack;

int i = 0;
double d = 0;

for (i = 0; i < 10; i++)
{
istack.push(i*i);
}

for (i = 0; i < 10; i++)
{
d = i * 0.01;
dstack.push(d);
}

for (i = 0; i < 10; i++)
{
cout << istack.pop() << "    ";
}
cout << endl << endl;

for (i = 0; i < 10; i++)
{
cout << dstack.pop() << "    ";
}
cout << endl;

cin >> i;
}

当然模板类中也可以不使用内联函数， 但模板类的声明和实现一定要放在一起，都放在头文件中，否则连接时会出现错误。原因是 由template <...> 处理的任何东西都意味着编译器在当时不为它分配存储空间，它一直处于等待状态直到被一个模板实例告知.

#include <iostream>

using namespace std;

#ifndef _STACK_H_
#define _STACK_H_

template <class T>
class stack
{
private:
enum {ssize = 100};
T m_stack[ssize];
int m_top;

public:
stack() : m_top(0) {m_stack[m_top] = 0;}
void push(T t);
T pop();
};

template <class T>
void stack<T>::push(T t)
{
if (m_top < ssize) {m_stack[m_top++] = t;};
}

template <class T>
T stack<T>::pop()
{
return m_stack[m_top > 0 ? --m_top : m_top];
}

#endif

使用模板时内存的释放

一个小小的例子，这个例子可以直接复制到程序中，来节省开发的时间。从例子中也可以看出， 模板类，或者是容器类他们对于对象类型并不负责内存的释放。

内存的释放还是由运行类自己进行的。

#include <iostream>
#include <vector>

using namespace std;

class Tester
{
private:
int m_id;

public:
Tester(int id): m_id(id){cout << "Construct a Tester: << "<< m_id << endl;}
~Tester(){cout << "Destruct a Tester: "<< m_id << endl;}

void run() {cout << "I am Tester: "<< m_id << endl;};
};

void main()
{
vector<Tester*> vec;
int i = 0;

vec.push_back(new Tester(1));
vec.push_back(new Tester(2));
vec.push_back(new Tester(3));
vec.push_back(new Tester(4));
vec.push_back(new Tester(5));

for (vector<Tester*>::iterator it = vec.begin(); it != vec.end(); it ++)
if (NULL != *it)
{
(*it)->run();
}

for (vector<Tester *>::iterator it = vec.begin(); it != vec.end(); it ++)
if (NULL != *it)
{
delete *it;
*it = NULL;
}
vec.clear();

cin >> i;
}

模板的继承：

模板类与我们普通的类一样支持继承。这里保留一个小例子，以后开发过程中可以直接扩展使用。这里使用的基类就是上面的栈的例子，这里从基类中派生出一个简单的子类，子类中增加了一个统计个数的功能。

stack_t.h

#include <iostream>

using namespace std;

#ifndef _STACK_H_
#define _STACK_H_

template <class T>
class stack
{
protected:
enum {ssize = 100};
T m_stack[ssize];
int m_top;

public:
stack() : m_top(0) {m_stack[m_top] = 0;}
void push(T t);
T pop();
};

template <class T>
void stack<T>::push(T t)
{
if (m_top < ssize) {m_stack[m_top++] = t;};
}

template <class T>
T stack<T>::pop()
{
return m_stack[m_top > 0 ? --m_top : m_top];
}

#endif

stack_static.h

#include <iostream>
#include "stack_t.h"

using namespace std;

#ifndef _STACK_STATIC_H_
#define _STACK_STATIC_H_

template <class T>
class stack_static : public stack<T>
{
public:
stack_static(){};

int count(){return m_top;};
};

#endif

main.cpp

#include "stack_static.h"

void main()
{
stack_static<int> istack;
stack_static<double> dstack;

int i = 0;
double d = 0;

for (i = 0; i < 10; i++)
{
istack.push(i*i);
}

for (i = 0; i < 10; i++)
{
d = i * 0.01;
dstack.push(d);
}

cout << "===================================" << endl;
cout << "Total count: " << dstack.count() << endl;
cout << "===================================" << endl;

for (i = 0; i < 10; i++)
{
cout << istack.pop() << "    ";
}
cout << endl << endl;

for (i = 0; i < 10; i++)
{
cout << dstack.pop() << "    ";
}
cout << endl;

cin >> i;
}