Question

假设您必须编写一个在客户端提供的类型上运行的模板库。另外，假设此库确实需要访问由客户端提供的类型参数化的全局变量。您将如何实施此模式？

Answer 1

以下是我用来模拟此行为的解决方案：

template <typename T> class Global {
public:    
    static T *pVar;

private:    
    Global() {}
    Global(const Global& rhs) {}
    void operator=(const Global& rhs) {}
};

template <typename T> T* Global<T>::pVar = new T;

它似乎做了我想要的特定应用程序。是否存在限制其适用性的问题？

Answer 2

@AnonymousCoward

这源于您的解决方案。请注意此变体中的初始化/销毁模式（如果您没有记忆输出，请阅读输出）。您可以使用它来推迟创建直到访问，并在终止时销毁和释放（这可能对自定义类型有用）：

#include <iostream>
#include <memory>

class t_custom {
public:
    t_custom() {
        std::cout << "custom ctor: " << __PRETTY_FUNCTION__ << "\n";
    }

    ~t_custom() {
        std::cout << "custom dtor: " << __PRETTY_FUNCTION__ << "\n";
    }
};

template<typename T>
class Global {
public:
    static T* Shared() {
        std::cout << "enter: " << __PRETTY_FUNCTION__ << "\n";
        static std::auto_ptr<T>pVar(new T);
        std::cout << "access: " << __PRETTY_FUNCTION__ << ":\t\t";
        return pVar.get();
    }

private:
    Global();
    ~Global();
    Global(const Global& rhs);
    Global& operator=(const Global& rhs);
};

template<typename T>
class Global_orig {
public:
    static T* const pVar;
private:
    Global_orig();
    Global_orig(const Global_orig& rhs);
    Global_orig& operator=(const Global_orig& rhs);
};

template<typename T>T* const Global_orig<T>::pVar(new T); // << oh no! global construction

int main(int argc, char* const argv[]) {

    std::cout << ">> main: " << __PRETTY_FUNCTION__ << "\n\n";

    std::cout << Global<float>::Shared() << "\n";
    std::cout << Global<int>::Shared() << "\n";
    std::cout << Global<t_custom>::Shared() << "\n";

    std::cout << Global_orig<t_custom>::pVar << "\n";

    std::cout << "\n<< main: " << __PRETTY_FUNCTION__ << "\n\n";

    return 0;
}

客户端为您提供工厂仿函数也许是一个好主意，而不是强迫他们使用T的默认初始化程序。

如何在C ++中定义全局变量模板？

2 个答案: