Альтернатива статической переменной в функции-члене

Question

Я полагался на неправильное представление о том, что статические переменные, определенные в функциях-членах, были ограничены конкретным экземпляром класса.

Чтобы проиллюстрировать мое неправильное представление:

#include <iostream>
#include <string>

struct Simple {
    template<typename T>
    T & Test(const T & Value) {
        static T Storage = Value;
        return Storage;
    }
};

int main() {
    Simple A;
    Simple B;

    std::string Foo = A.Test(std::string("Foo"));
    std::string Bar = B.Test(std::string("Bar"));

    std::cout << Foo << ' ' << Bar << std::endl;
}

Ожидаемое поведениепривели к выводу

Foo Bar

Есть ли простая альтернатива, которая привела бы к ожидаемому поведению?

Править

Урезанная версия класса, в которой возникла проблема:

class SignalManager {
    private:
        template<typename T> struct FunctionPointer { typedef boost::function1<void, const T &> type; };
        template<typename T> struct Array { typedef std::vector<typename FunctionPointer<T>::type> type; };

        template<typename T>
        typename Array<T>::type & GetArray() {
            static typename Array<T>::type Array;
            return Array;
        }

    public:
        template<typename T, typename M>
        void Broadcast(const M & Value) {
            typename Array<T>::type::iterator Iterator;
            for(Iterator = GetArray<T>().begin(); Iterator != GetArray<T>().end(); ++Iterator) {
                (*Iterator)(Value);
            }
        }

        template<typename T, typename F>
        void Connect(const F & Function) {
            GetArray<T>().push_back(Function);
        }
};

Answer 1

Если я понимаю вашу путаницу, альтернативой являются переменные-члены ...

template<typename T>
struct Simple {
    T storage;

    T & Test(const T & Value) {
        storage = Value;
        return Storage;
    }
};

Answer 2

Вы можете просто превратить его в обычную нестатическую переменную класса, хотя для этого потребуется, чтобы класс был шаблоном, а не функцией ...

template<typename T>
struct Simple
{
    T& Test( const T& value )
    {
        storage = value;
        return storage;
    }
private:
    T storage;
}

Answer 3

static T Storage = Value;

Приведенный выше оператор выполняется только один раз, несмотря на многочисленные вызовы функции-члена Test. Итак, вместо этого разделите объявление и инициализацию.

template<typename T>
T & Test(const T & Value) {         
     static T Storage;
     Storage = Value;   // Now, this is guaranteed to execute during member function calls.
    return Storage;
}

Это должно получить то, что вы хотите.