我想我有你想要的答案，或者，至少，我几乎有。它使用您建议的调度风格很愚蠢，但我认为它符合您提出的前两个标准，或多或少符合第三个标准。
- 包装类根本不需要修改。
- 它根本不修改被包装的类。
- 它只是通过引入调度函数来改变语法。
基本思想是创建一个模板类，其参数是要包装的对象的类，带有一个模板dispatch方法，其参数是成员函数的参数和返回类型。 dispatch 方法查找传入的成员函数指针，看它之前是否被调用过。如果是这样，它会检索先前方法参数和计算结果的记录，以返回先前计算的值，用于分配给调度的参数，或者如果它是新的，则计算它。
由于这个包装类的作用也称为memoization，因此我选择将模板称为Memo，因为它的类型比CacheWrapper 更短，而且我在晚年开始更喜欢较短的名称.
#include <algorithm>
#include <map>
#include <utility>
#include <vector>
// An anonymous namespace to hold a search predicate definition. Users of
// Memo don't need to know this implementation detail, so I keep it
// anonymous. I use a predicate to search a vector of pairs instead of a
// simple map because a map requires that operator< be defined for its key
// type, and operator< isn't defined for member function pointers, but
// operator== is.
namespace {
template <typename Type1, typename Type2>
class FirstEq {
FirstType value;
public:
typedef std::pair<Type1, Type2> ArgType;
FirstEq(Type1 t) : value(t) {}
bool operator()(const ArgType& rhs) const {
return value == rhs.first;
}
};
};
template <typename T>
class Memo {
// Typedef for a member function of T. The C++ standard allows casting a
// member function of a class with one signature to a type of another
// member function of the class with a possibly different signature. You
// aren't guaranteed to be able to call the member function after
// casting, but you can use the pointer for comparisons, which is all we
// need to do.
typedef void (T::*TMemFun)(void);
typedef std::vector< std::pair<TMemFun, void*> > FuncRecords;
T memoized;
FuncRecords funcCalls;
public:
Memo(T t) : memoized(t) {}
template <typename ReturnType, typename ArgType>
ReturnType dispatch(ReturnType (T::* memFun)(ArgType), ArgType arg) {
typedef std::map<ArgType, ReturnType> Record;
// Look up memFun in the record of previously invoked member
// functions. If this is the first invocation, create a new record.
typename FuncRecords::iterator recIter =
find_if(funcCalls.begin(),
funcCalls.end(),
FirstEq<TMemFun, void*>(
reinterpret_cast<TMemFun>(memFun)));
if (recIter == funcCalls.end()) {
funcCalls.push_back(
std::make_pair(reinterpret_cast<TMemFun>(memFun),
static_cast<void*>(new Record)));
recIter = --funcCalls.end();
}
// Get the record of previous arguments and return values.
// Find the previously calculated value, or calculate it if
// necessary.
Record* rec = static_cast<Record*>(
recIter->second);
typename Record::iterator callIter = rec->lower_bound(arg);
if (callIter == rec->end() || callIter->first != arg) {
callIter = rec->insert(callIter,
std::make_pair(arg,
(memoized.*memFun)(arg)));
}
return callIter->second;
}
};
这里有一个简单的测试来展示它的使用：
#include <iostream>
#include <sstream>
#include "Memo.h"
using namespace std;
struct C {
int three(int x) {
cout << "Called three(" << x << ")" << endl;
return 3;
}
double square(float x) {
cout << "Called square(" << x << ")" << endl;
return x * x;
}
};
int main(void) {
C c;
Memo<C> m(c);
cout << m.dispatch(&C::three, 1) << endl;
cout << m.dispatch(&C::three, 2) << endl;
cout << m.dispatch(&C::three, 1) << endl;
cout << m.dispatch(&C::three, 2) << endl;
cout << m.dispatch(&C::square, 2.3f) << endl;
cout << m.dispatch(&C::square, 2.3f) << endl;
return 0;
}
在我的系统上产生以下输出（使用 g++ 4.0.1 的 MacOS 10.4.11）：
称为三(1)
3
称为三(2)
3
3
3
叫方(2.3)
5.29
5.29
注意事项
- 这仅适用于采用 1 个参数并返回结果的方法。它不适用于采用 0 个参数、2 个、3 个或更多参数的方法。不过，这应该不是什么大问题。您可以实现分派的重载版本，该版本采用不同数量的参数，直至某个合理的最大值。这就是Boost Tuple library 所做的。他们实现了最多 10 个元素的元组，并假设大多数程序员不需要更多。
- 为调度实现多个重载的可能性是我使用 FirstEq 谓词模板和 find_if 算法而不是简单的 for 循环搜索的原因。单次使用的代码要多一些，但如果您要多次进行类似的搜索，最终会减少整体代码，并且导致其中一个循环出现细微错误的机会也较小。
- 它不适用于不返回任何内容的方法，即
void，但如果该方法不返回任何内容，则无需缓存结果！
- 它不适用于包装类的模板成员函数，因为您需要将实际的成员函数指针传递给调度，而未实例化的模板函数（还）没有指针。可能有办法解决这个问题，但我还没有尝试太多。
- 我还没有对此进行太多测试，因此它可能存在一些微妙（或不那么微妙）的问题。
- 我认为在 C++ 中不可能有一个完全无缝的解决方案，它可以完全满足您的所有要求，并且完全不改变语法。 （尽管我很想被证明是错误的！）希望这已经足够接近了。
- 当我研究这个答案时，我从this very extensive write up 获得了很多关于在 C++ 中实现成员函数委托的帮助。任何想要了解比他们意识到的更多关于成员函数指针的知识的人都应该好好阅读这篇文章。