我遇到的问题---大师级人物请帮忙！

[meteor135]

请大家分析我的自编程序，就问题提出解决方案。
//TestTemplateAndPlanarArray.cpp
//Author:Meteor135
//Time:2003.5.17

#include <iostream.h>

const unsigned MAXROW = 3;//数组行数
const unsigned MAXCOL = 4;//数组列数

template <class T>
void Input(T *data)
//当把这些指针符号*都去掉后编译能通过，可是显然无法实现我的目标。
{
cout<<"Input a T:";
cin>>*data;
}

template <class T>
void Output(T data)
{
cout<<data;
}
//我的程序中为什么模板函数和实例函数都不可缺少？
//否则无法通过编译。
//现在不能通过编译的问题不是这里。
void Input(int *data)
{
cout<<"Input a int:";
cin>>*data;
}

void Output(int data)
{
cout<<data<<" ";
}

void Input(char *data)
{
cout<<"Input a char:";
cin>>*data;
}

void Output(char data)
{
cout<<data;
}
/*遍历二维数组*/
template <class T>
void TraversePlanarArray(T **array, void (*pFunc)(T)/*原打算这里用模板函数指针，但是编译通不过，有没有替代方案？*/)
{
T **pArray;
T *pEle;
unsigned row,col;
for(row=0,pArray=array;row<MAXROW;pArray = &array[++row])
{//for最后的语句可不可以改成row++,pArray++?
for(col=0,pEle=pArray[row];col<MAXCOL;col++,pEle++)
{
pFunc(*pEle);
}
cout<<endl;
}
}

/*初始化二维数组*/
template<class T>
void InitPlanarArray(T *array[MAXCOL])
{
TraversePlanarArray(array,Input<T>);//这里编译有错误！！如何修改？
}

/*输出二维数组*/
template<class T>
void OutputPlanarArray(T *array[MAXCOL])
{
TraversePlanarArray(array,Output<T>);
}

/*全程操作二维数组*/
template <class T>
void TestTemplateAndArray()
{
T **TArray = new T*[MAXROW];
for(unsigned i=0;i<MAXROW;i++)
TArray[i]=new T[MAXCOL];

InitPlanarArray(TArray);

OutputPlanarArray(TArray);

for(i=0;i<MAXROW;i++)
delete[] TArray[i];
delete[] TArray;
}

void main()
{
/*测试整型*/
TestTemplateAndArray<int>();
/*测试字符型*/
TestTemplateAndArray<char>();
}

//难道不可以定义指向模板函数的指针类型？
//如果可以，如何实现？
//还有，为什么下面的语法是错的？
//int a[12][10];
//int *p[10]=a;
//如何修改？

[meteor135]

谢谢楼上几位的回复，等我确认各位的解决方案之后再结帖放分。

to plainsong(伤心的风★短歌),你的回复我比较能理解，只是你的关于下面这个问题
“
int a[12][10];
int *p[10]=a;
“
的解释我自己已经解决并表示回复了，你可能没看到吧。

另外关于 jhwh(弹剑长歌) 的回复，我未置可否，因为我觉得他没有指出问题根本之所在，对此意见我暂时保留。
对于solotony的回复，我发现其中有些语法我都没见过，所以暂时我还不敢贸然采纳。

另外，这里不欢迎广告！


欢迎大家继续提出自己的看法！

[短歌如风]

　　对不起，看的不够仔细，把楼主已经解决了的问题又说了遍。不过楼主没有把解决的方法写出来，就当是我替楼主写的吧。

　　楼主说的对，这里不欢迎广告！删除之……

　　solotony的回复并没有什么特殊语法啊，我想楼主可能是没有明白“函数对象”的使用，其时他是把楼主的函数（Input和Output）改成了函数对象。
不过他没有用楼主的代码而是使用了标准函数（模板）for_each来举的例子：
for_each(a, a+MAX, input<T>());
for_each(a, a+MAX, ouput<T>());
input<T>()其实是构造了一个对象并传给了for_each，这个对象的类型是input<T>，他是在说明如何使用函数对象而不是函数指针来把某个可执行单元作为参数传递给一个函数，只是少了些文字说明。

[meteor135]

看来楼上兄弟也是经常光顾论坛啊，不错不错。

说实话，对于函数对象这个概念还真是第一次听说，所以对于它的定义方式、使用方式等等都不是很清楚。其实我对于范型技术整块都不是很了解，只知道些粗浅的东西，所以还需要各位前人多多指教！
多谢各位！

[meteor135]

这是我当时的一个最新版本，你看看问题何在，如何用你们的方法修改？
//TestTemplateAndPlanarArray.cpp
//Author:Meteor135
//Time:2003.5.17

#include <iostream.h>

template <class T>
void Input(T &data)
{
cout<<"Input a T:";
cin>>data;//这里无法重载适当的运算符！
}

template <class T>
void Output(T &data)
{
cout<<data<<" ";
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TraversePlanarArray(T (*array)[MAXCOL], void (*pFunc)(T&))
{
T (*pArray)[MAXCOL];
T *pEle;
unsigned row,col;
for(row=0,pArray=array;row<MAXROW;row++,pArray++)
{
for(col=0,pEle=*pArray;col<MAXCOL;col++,pEle++)
{
pFunc(*pEle);
}
cout<<endl;
}
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void InitPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,(void (*)(T&))Input<T&>);
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void OutputPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,(void (*)(T&))Output<T&>);
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TestTemplateAndArray()
{
T TArray[MAXROW][MAXCOL];
InitPlanarArray<T,MAXROW,MAXCOL>(TArray);
OutputPlanarArray<T,MAXROW,MAXCOL>(TArray);
}

void main()
{
cout<<"测试整型"<<endl;
TestTemplateAndArray<int, 3, 6>();
cout<<"测试字符型"<<endl;
TestTemplateAndArray<char, 4, 5>();
}

[xueweizhong]

我把你最先贴的代码简化了一下，主要是帮你解决一下编译问题，
所以把不重要的代码都略去了:

/*
* simplified by xueweizhong
*/

template <class T>
void Input(T *data) {} // ---------#1

template <class T>
void TraversePlanarArray(T**, void (*)(T))
{} // ---------#2

template<class T>
void InitPlanarArray(T** array)
// ----------#3
{
TraversePlanarArray(array,Input<T>);
//-----------#4
//这里有编译错误,如何修改
}

int main()
{
InitPlanarArray((int**)0);
//-------#5
}

关于#4编译出错的原因：
#5调用---> #3实例化 模板参数T 推导为 int : T** --> (int**)
-->#4的调用:
arg1 = T** = int**
arg2 = Input<int> = void (int*)--> void (*)(int*)
而按照#2 形参分别为:
para1 = T**
para2 = void (*)(T)
于是有参数推导:
para1/arg1 --> T**/int** --> T = int
para2/arg2 --> void(*)(T)/void(*)(int*) --> T = int*
两个推导对同一模板参数T导出不同结果,所以发生编译错误。

解决方法为:
1: 你不是很愿意的结果 #1改为
template <class T>
void Input(T data) {} // ---------把T* 改为 T
2: 把#2中的函数指针类型修改：
template <class T>
void TraversePlanarArray(T**, void (*)(T*))
// ---------把T改成T*,
// 当然函数实现也需要跟着修改了。

其他1：
#4 中Input<T>的<T>（explicit-template-argument)不能少,因为C++STD98不允许在
模板参数推导过程中使用模板函数指针。
/*据说C++0X将同意使用这种方式，未来的编译器可能接受它*/

另外建议将 Input<T>写为 &Input<T>，这样编译器在推导类型时确认为函数指针类型而
非“函数类型”（函数类型可以让许多C++ compiler出现错误，尽量避免）
当然可以这样写：
void (*f_ptr)(T) = Input<T>; // overload resolution happens!!!
TraversePlanarArray(array,f_ptr);
这是最好的做法。

其他2：

另外你最后贴的这个版本把所有模板函数调用都加上了显式的模板argument,
显得有些别扭，另外还有两个小错误：
TraversePlanarArray<T,MAXROW,MAXCOL>(array,(void (*)(T&))Input<T&>);
TraversePlanarArray<T,MAXROW,MAXCOL>(array,(void (*)(T&))Output<T&>);
需改为：
TraversePlanarArray<T,MAXROW,MAXCOL>(array,(void (*)(T&))Input<T>);
TraversePlanarArray<T,MAXROW,MAXCOL>(array,(void (*)(T&))Output<T>);
不然会产生引用的引用问题。

其他3：
说老实话，你的代码C++ smell too little ^_^(C smell too much ??
student smell?)
just do better, then you'll nerver been boring again.

[短歌如风]

//使用“函数对象”方法1：
#include <iostream.h>

template <class T>
class Input
{
public:
void operator ()(T &data)
{
cout<<"Input a T:";
cin>>data;//这里无法重载适当的运算符！
}
};

template <class T>
class Output
{
public:
void operator ()(T &data)
{
cout<<data<<" ";
}
};

template <class T, unsigned MAXROW, unsigned MAXCOL, typename OP>//这里要加一个模板参数
void TraversePlanarArray(T (*array)[MAXCOL], const OP & pFunc)
{
T (*pArray)[MAXCOL];
T *pEle;
unsigned row,col;
for(row=0,pArray=array;row<MAXROW;row++,pArray++)
{
for(col=0,pEle=*pArray;col<MAXCOL;col++,pEle++)
{
pFunc(*pEle);
}
cout<<endl;
}
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void InitPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Input<T>());
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void OutputPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Output<T>());
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TestTemplateAndArray()
{
T TArray[MAXROW][MAXCOL];
InitPlanarArray<T,MAXROW,MAXCOL>(TArray);
OutputPlanarArray<T,MAXROW,MAXCOL>(TArray);
}

void main()
{
cout<<"测试整型"<<endl;
TestTemplateAndArray<int, 3, 6>();
cout<<"测试字符型"<<endl;
TestTemplateAndArray<char, 4, 5>();
cin.get();
}

[短歌如风]

//使用函数对象方法2：使用“多态函数对象”
#include <iostream.h>
template <typename T>
class Function
{
virtual void Execute(T data) = 0;
public:
void operator () (T data)
{
Execute(data);
}
};

template <typename T>
class Input: public Function<T&>
{
void Execute(T& data);
};

template <typename T>
void Input<T>::Execute(T& data)
{
cout<<"Input a T:";
cin>>data;
}

template <typename T>
class Output: public Function<T&>
{
void Execute(T& data);
};

template <typename T>
void Output<T>::Execute(T& data)
{
cout<<data<<" ";
}

template <class T, unsigned MAXROW, unsigned MAXCOL>//由于使用了“多态”，这里可以省去一个模板参数
void TraversePlanarArray(T (*array)[MAXCOL], const Function<T&> & pFunc)
{
T (*pArray)[MAXCOL];
T *pEle;
unsigned row,col;
for(row=0,pArray=array;row<MAXROW;row++,pArray++)
{
for(col=0,pEle=*pArray;col<MAXCOL;col++,pEle++)
{
pFunc(*pEle);
}
cout<<endl;
}
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void InitPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Input<T>());
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void OutputPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Output<T>());
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TestTemplateAndArray()
{
T TArray[MAXROW][MAXCOL];
InitPlanarArray<T,MAXROW,MAXCOL>(TArray);
OutputPlanarArray<T,MAXROW,MAXCOL>(TArray);
}

void main()
{
cout<<"测试整型"<<endl;
TestTemplateAndArray<int, 3, 6>();
cout<<"测试字符型"<<endl;
TestTemplateAndArray<char, 4, 5>();
cin.get();
}

[meteor135]

我已见到你的回复，且容我研读一段时间。

[magicblue]

it is c, with template, boring code

[短歌如风]

对不起，忘了一点：
两段代码中的成员函数和操作符都应该是const的：
void opreator ()(T& data) const;
void Execute()(T data) const;

由于你的代码我编译无法通过，所我不知道它执行起来是什么样的，更不知道你想要的结果是什么，能不能详细说一下？

[meteor135]

那就先说我的目的吧
就是当测试整型时，我输入123它应该把123作为整数123保存到一个数组元素当中去；
当我测试字符型时，我输入123它应该把123当做3个字符'1''2''3'保存到3个数组元素中去。
这本就是输入流对象自己具备的识别功能，我之所以到此来询问，是因为这个对象无法实现此功能了。
我原来的程序所谓的达不到目的就是指它总是把123当作三个单个的数字或者字符处理。

这下你明白了吗？

你上面提到的是不是const我想无关紧要吧？我们暂时可以不考虑这个问题。

[短歌如风]

我在BCB6、VC6和Dev C++ 4.9.8.0中都试过了，完全符合你的要求。
在Dev C++中要把#include <iostream.h>改为
#include <iostream>
using namespace std;
(事实上iostream.h是旧的头文件，不提倡使用)并且main的返回值必须是int不能是void。

运行结果：

测试字符型
Input a T:123456
Input a T:Input a T:Input a T:Input a T:
Input a T:Input a T:111222
Input a T:Input a T:Input a T:
Input a T:Input a T:Input a T:a
Input a T:f
Input a T:g

Input a T:dfsd
Input a T:Input a T:Input a T:Input a T:d

1 2 3 4 5
6 1 1 1 2
2 2 a f g
d f s d d

[短歌如风]

测试整型
Input a T:12345
Input a T:54321
Input a T:123 123 456 789
Input a T:Input a T:Input a T:
Input a T:2323
Input a T:2354
Input a T:22
Input a T:33
Input a T:44
Input a T:55

Input a T:66
Input a T:77
Input a T:88
Input a T:99
Input a T:21
Input a T:22

12345 54321 123 123 456 789
2323 2354 22 33 44 55
66 77 88 99 21 22
测试字符型
Input a T:1234567890
Input a T:Input a T:Input a T:Input a T:
Input a T:Input a T:Input a T:Input a T:Input a T:
Input a T:09876543
Input a T:Input a T:Input a T:Input a T:
Input a T:Input a T:Input a T:Input a T:21
Input a T:
1 2 3 4 5
6 7 8 9 0
0 9 8 7 6
5 4 3 2 1

[meteor135]

这就是我用于测试的代码：
难道和你的不一样？
还是没有你实现的效果，要不你把你的完全通过的代码贴上来

//使用函数对象方法2：使用“多态函数对象”
#include <iostream.h>
template <typename T>
class Function
{
virtual void Execute(T data) const = 0 ;//按你的要求加了const,以下同。
public:
void operator () (T data) const
{
Execute(data);
}
};

template <typename T>
class Input: public Function<T&>
{
void Execute(T& data) const;
};

template <typename T>
void Input<T>::Execute(T& data) const
{
cout<<"Input a T:";
cin>>data;
}

template <typename T>
class Output: public Function<T&>
{
void Execute(T& data) const;
};

template <typename T>
void Output<T>::Execute(T& data) const
{
cout<<data<<" ";
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TraversePlanarArray(T (*array)[MAXCOL], const Function<T&> & pFunc)
{
T (*pArray)[MAXCOL];
T *pEle;
unsigned row,col;
for(row=0,pArray=array;row<MAXROW;row++,pArray++)
{
for(col=0,pEle=*pArray;col<MAXCOL;col++,pEle++)
{
pFunc(*pEle);
}
cout<<endl;
}
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void InitPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Input<T>());
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void OutputPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Output<T>());
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TestTemplateAndArray()
{
T TArray[MAXROW][MAXCOL];
InitPlanarArray<T,MAXROW,MAXCOL>(TArray);
OutputPlanarArray<T,MAXROW,MAXCOL>(TArray);
}

void main()
{
cout<<"测试整型"<<endl;
TestTemplateAndArray<int, 3, 6>();
cout<<"测试字符型"<<endl;
TestTemplateAndArray<char, 4, 5>();
cin.get();
}

[短歌如风]

对不起，我又重新试了一下，在VC6中确实不正常，可能刚才我没有注意到。我上面贴出来的是在Dev C++中的运行结果。
　　原因正在找，找到了我会贴在这里。

[短歌如风]

　　如果你把字符型的测试代码去掉，整数输入就正确了。我一开始之所以没有发现就是因为我是对两种类型分别测试的。
　　至于为什么用字符类型实例化模板会影响整数类型，我做了个试验：

代码一：
#include <iostream>
#include <typeinfo>

template <typename T>
void Test()
{
std::cout << "T is:" << typeid(T).name() << std::endl;
}
void main()
{
Test<int>();
Test<char>();
}
结果：
T is:char
T is:char

代码二：
#include <iostream>
#include <typeinfo>

template <typename T>
void Test()
{
std::cout << "T is:" << typeid(T).name() << std::endl;
}
void main()
{
Test<char>();
Test<int>();
}
T is:int
T is:int

代码三：
#include <iostream>
#include <typeinfo>

template <typename T>
void Test(const T&)
{
std::cout << "T is:" << typeid(T).name() << std::endl;
}
void main()
{
Test<char>('\0');
Test<int>(0);
}
T is:char
T is:int

可见，当模板函数的类型参数没有出现在参数列表中时，VC6对函数签名的生成处理的不好，对不同的类型生成了相同的签名，这也算是一个Bug吧。在BCB和Dev C++中没有这个问题。

解决办法：为你的TestTemplateAndArray函数加一个不使用的参数。修改如下（我只贴修改的部分）：
template <class T, unsigned MAXROW, unsigned MAXCOL>
void TestTemplateAndArray(const T&)
{
T TArray[MAXROW][MAXCOL];
InitPlanarArray<T,MAXROW,MAXCOL>(TArray);
OutputPlanarArray<T,MAXROW,MAXCOL>(TArray);
}

void main()
{
cout<<"测试整型"<<endl;
TestTemplateAndArray<int, 3, 6>(0);
cout<<"测试字符型"<<endl;
TestTemplateAndArray<char, 4, 5>(0);
cin.get();
}

如果可以保证应用时T一定有缺省构造函数（所有的简单类型以及std::string等类型都符合条件）也可以给这个参数一个缺省值：
void TestTemplateAndArray(const T& = T())
这样调用这个函数的地方就都不用动了。

[meteor135]

本人当初编写这个程序就是为了使用模板和一些参数传递机制，干吗非要跟c过不去呢？
没见我就是为了Test吗？

[meteor135]

我在VC6.0下编译你提供的两种方式的程序（我也尝试过在Dev C++下编译，错误更多），其中函数对象方式的错误信息：
--------------------Configuration: FuncObj - Win32 Debug--------------------
Compiling...
FuncObj.cpp
D:\download\自己的\FuncObj\FuncObj.cpp(35) : error C2662: '()' : cannot convert 'this' pointer from 'const class Input<char>' to 'class Input<char> &'
Conversion loses qualifiers
D:\download\自己的\FuncObj\FuncObj.cpp(44) : see reference to function template instantiation 'void __cdecl TraversePlanarArray(char (*)[5],const class Input<char> &)' being compiled
D:\download\自己的\FuncObj\FuncObj.cpp(35) : error C2064: term does not evaluate to a function
D:\download\自己的\FuncObj\FuncObj.cpp(44) : see reference to function template instantiation 'void __cdecl TraversePlanarArray(char (*)[5],const class Input<char> &)' being compiled
D:\download\自己的\FuncObj\FuncObj.cpp(35) : error C2662: '()' : cannot convert 'this' pointer from 'const class Output<char>' to 'class Output<char> &'
Conversion loses qualifiers
D:\download\自己的\FuncObj\FuncObj.cpp(50) : see reference to function template instantiation 'void __cdecl TraversePlanarArray(char (*)[5],const class Output<char> &)' being compiled
D:\download\自己的\FuncObj\FuncObj.cpp(35) : error C2064: term does not evaluate to a function
D:\download\自己的\FuncObj\FuncObj.cpp(50) : see reference to function template instantiation 'void __cdecl TraversePlanarArray(char (*)[5],const class Output<char> &)' being compiled
Error executing cl.exe.

FuncObj.exe - 4 error(s), 0 warning(s)

对于这两个程序，我把那个const删掉之后都能通过编译，但是执行结果和我自己的版本没两样，都没有实现我的目标。

还望plainsong(伤心的风★短歌)兄弟多多指教！

[meteor135]

我原来的这个做了少许修改，现已在Dev C++下通过
//TestTemplateAndPlanarArray.cpp
//Author:Meteor135
//Time:2003.7.23
//Compiler:Bloodshed Dev C++ 4.9.8.0

#include <iostream>//修改1
using namespace std;//修改2

template <class T>
void Input(T &data)
{
cout<<"Input a T:";
cin>>data;
}

template <class T>
void Output(T &data)
{
cout<<data<<" ";
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TraversePlanarArray(T (*array)[MAXCOL], void (*pFunc)(T&))
{
T (*pArray)[MAXCOL];
T *pEle;
unsigned row,col;
for(row=0,pArray=array;row<MAXROW;row++,pArray++)
{
for(col=0,pEle=*pArray;col<MAXCOL;col++,pEle++)
{
pFunc(*pEle);
}
cout<<endl;
}
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void InitPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Input<T>);//修改3
}

template<class T, unsigned MAXROW, unsigned MAXCOL>
void OutputPlanarArray(T (*array)[MAXCOL])
{
TraversePlanarArray<T,MAXROW,MAXCOL>(array,Output<T>);//修改4
}

template <class T, unsigned MAXROW, unsigned MAXCOL>
void TestTemplateAndArray()
{
T TArray[MAXROW][MAXCOL];
InitPlanarArray<T,MAXROW,MAXCOL>(TArray);
OutputPlanarArray<T,MAXROW,MAXCOL>(TArray);
}

int main()//修改5
{
cout<<"测试整型"<<endl;
TestTemplateAndArray<int, 3, 6>();
cout<<"测试字符型"<<endl;
TestTemplateAndArray<char, 4, 5>();
//这里加什么专门用于让窗口不消失以便于观看结果的代码？
return 0;//修改6
}

[lemonutzf]

我看了各位的代码，写得都很好呀，就那个程序来说，不管是用函数指针还是用函数对象，问题大概已经解决了吧。我写这个贴的意思是：是否应该关注一下效率问题和生成代码的长度问题，template <class T, unsigned MAXROW, unsigned MAXCOL>
void TraversePlanarArray(T (*array)[MAXCOL], void (*pFunc)(T&))
这个模板对每一个不同的列和行，都会生成一个函数实例，是不是太奢侈了，我的想法是把行列给抽出来，改成：
template <class T, unsigned MAXROW, unsigned MAXCOL>
inline void TraversePlanarArray(T (*array)[MAXCOL], void (*pFunc)(T&))
{
TraversePlanarArray_<T>(*array,MAXROW*MAXCOL,pFunc);
}
template <class T>
inline void TraversePlanarArray_(T array[], int TOTAL,void (*pFunc)(T&))
{
for(int i=0;i<TOTAL;++i)
pFunc(*(array++));
}
这样生成的代码会少很多，起码，同一类型的数组只生成一个版本的traverse函数，并且，舍弃了二重循环，为inline提供了可能，以增加效率。
此代码已在vc6.0下通过，和你的意图一样，你只要把这段代码把你的traverse函数替换掉就可以了，如果用函数对象，并把input,output也变成inline形式的话，效果更佳.
陋见:)