универсальная неразрушающая обертка кэша

Я думаю, что у меня есть ответ, который вы ищете, или, по крайней мере, я почти знаю. Он использует стиль отправки, который вы предложили глупо, но я думаю, что он соответствует первым двум критериям, которые вы указали, и более или менее соответствует третьему.

1. Класс упаковки вообще не нужно изменять.
2. Он вообще не модифицирует обернутый класс.
3. Он только изменяет синтаксис, вводя функцию диспетчеризации.

Основная идея состоит в том, чтобы создать шаблонный класс, параметром которого является класс объекта, который нужно обернуть, с помощью метода шаблона 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;
}

Что дает следующий результат в моей системе (MacOS 10.4.11 с использованием g ++ 4.0.1):

Called three(1)
3
Called three(2)
3
3
3
Called square(2.3)
5.29
5.29

ПРИМЕЧАНИЯ

• Это работает только для методов, которые принимают 1 аргумент и возвращают результат. Это не работает для методов, которые принимают 0 аргументов, или 2, или 3, или более аргументов. Однако это не должно быть большой проблемой. Вы можете реализовать перегруженные версии диспетчеризации, которые принимают разное количество аргументов до некоторого разумного максимума. Это то, что делает библиотека Boost Tuple . Они реализуют кортежи, содержащие до 10 элементов, и предполагают, что большинству программистов не нужно больше этого.
• Возможность реализации нескольких перегрузок для диспетчеризации - вот почему я использовал шаблон предиката FirstEq с алгоритмом find_if вместо простого поиска по циклу. . Это немного больше кода для одноразового использования, но если вы собираетесь выполнить аналогичный поиск несколько раз, в итоге будет меньше кода в целом и меньше шансов получить неуловимую ошибку в одном из циклов.
• Это не работает для методов, ничего не возвращающих, т.е. void , но если метод ничего не возвращает, тогда вам не нужно кэшировать результат!
• Он не работает для функций-членов шаблона обернутого класса, потому что вам нужно передать фактическую функцию-член указатель на отправку, а неустановленная функция-шаблон не имеет указателя (пока). Возможно, есть способ обойти это, но я еще не очень много пробовал.
• Я еще не проводил большого тестирования этого, поэтому могут возникнуть некоторые тонкие (или не очень тонкие) проблемы.
• Я не Я думаю, что на C ++ возможно полностью бесшовное решение, которое удовлетворяет всем вашим требованиям без каких-либо изменений синтаксиса. (хотя я бы хотел, чтобы меня доказали, что он неправ!). Надеюсь, это достаточно близко.
• Когда я исследовал этот ответ, мне очень помогли эта очень обширная статья о реализации делегатов функций-членов в C ++. Любой, кто хочет узнать об указателях на функции-члены больше, чем они думали, должен внимательно прочитать эту статью.