指向全局实例的模板类作为模板参数？

Question

我想实现下面的代码的通用版本：

#include <iostream> 

class ContainerA 
{ 
    public: 
     ContainerA(int newData) 
      : mData_(newData) 
     {} 
     int mData_; 
}; 

class ContainerB 
{ 
    public: 
     ContainerB(int newData) 
      : mData_(newData) 
     {} 
     int mData_; 
}; 

ContainerA staticInstanceA(3); 
ContainerB staticInstanceB(11); 

template< ContainerA* ptrToContainer > 
class WorkerOnA 
{ 
    public: 
     WorkerOnA() 
      : mPtrToContainer_(ptrToContainer) 
     {} 

     void operator()() 
     { 
      std::cout << "Data = " << mPtrToContainer_->mData_ << '\n'; 
     } 

    private: 
     ContainerA* mPtrToContainer_; 
}; 

template< ContainerB* ptrToContainer > 
class WorkerOnB 
{ 
    public: 
     WorkerOnB() 
      : mPtrToContainer_(ptrToContainer) 
     {} 

     void operator()() 
     { 
      std::cout << "Data = " << mPtrToContainer_->mData_ << '\n'; 
     } 

    private: 
     ContainerB* mPtrToContainer_; 
}; 

int main() 
{ 
    WorkerOnA<&staticInstanceA> workerOnAInstance; 
    WorkerOnB<&staticInstanceB> workerOnBInstance; 

    workerOnAInstance(); 
    workerOnBInstance(); 

    return 0; 
} 

我想有（如果这是可能的），是一个工人模板类，它可以被实例化工作在任一容器上，例如：

template< ?? ptrToContainer > 
class WorkerOnAnyContainer 
{ 
    public: 
     WorkerOnA() 
      : mPtrToContainer_(ptrToContainer) 
     {} 

     void operator()() 
     { 
      std::cout << "Data = " << mPtrToContainer_->mData_ << '\n'; 
     } 

    private: 
     ?? mPtrToContainer_; 
}; 

但是，几个小时后，我仍然无法确定'??'应该是什么。也许模板向导有一个想法？

更新1：修复了工人（ptrToContainer - > mPtrToContainer_）的'operator（）'中的错误。对不起。

更新2：我得到了一些工作，但我仍然会好奇，如果任何人有更好的主意。例如，拥有一个模板参数会很好。有谁知道如果“模板模板参数”可以在这种情况下帮助吗？

template< class TContainer, TContainer* ptrToContainer > 
class Worker 
{ 
    public: 
     Worker() 
      : mPtrToContainer_(ptrToContainer) 
     {} 

     void operator()() 
     { 
      std::cout << "Data = " << mPtrToContainer_->mData_ << '\n'; 
     } 

    private: 
     TContainer* mPtrToContainer_; 
}; 

感谢， d

Answer 1

我给它一个镜头。如何改变你的模板，使它被赋予类型作为参数，而不是指针本身？您还可以通过在指针的构造函数：

template< typename TContainer > 
class WorkerOnAnyContainer 
{ 
    public: 
     WorkerOnA(TContainer* ptrToContainer) 
      : mPtrToContainer_(ptrToContainer) 
     {} 

     void operator()() 
     { 
      std::cout << "Data = " << mPtrToContainer_->mData_ << '\n'; 
     } 

    private: 
     TContainer* mPtrToContainer_; 
}; 

然后，你可以使用它像：

WorkerOnAnyContainer<ContainerA> workerOnAInstance(&staticInstanceA); 

---

既然你想保持指针作为模板参数设计，你可以像这样的东西去：

template< typename TContainer, TContainer* ptrToContainer > 
class WorkerOnAnyContainer 
{ 
    public: 
     WorkerOnA() 
      : mPtrToContainer_(ptrToContainer) 
     {} 

     void operator()() 
     { 
      std::cout << "Data = " << ptrToContainer->mData_ << '\n'; 
     } 

    private: 
     TContainer* mPtrToContainer_; 
}; 

而且使用它像：

WorkerOnAnyContainer<ContainerA, &staticInstanceA> workerOnAInstance; 

---

但是，这是有点乱，因为你需要两个模板参数，第一个感觉是多余的。我不知道这是可能的C++ 03解决这个问题，但我想这将有可能建立一个辅助方法，可以做的类型扣除我们在C++ 11：

template<typename T> 
auto CreateWorker(T* container) -> WorkerOnAnyContainer<T, container> 
{ 
    return WorkerOnAnyContainer<T, container>(); 
} 

但，因为编译器期望的功能，对于非编译时const的参数工作，这并不编译（GCC 4.6.3）：

use of parameter 'container' outside function body 

原来you're not the only one trying to do this。显然，即使使用C++ 11，也无法以这种方式创建辅助方法。

我能想到的，实际工作的唯一事情是使用宏（我知道，我知道）：

#define CreateWorker(container) WorkerOnAnyContainer<decltype(container), &container>() 

然后使用它很简单，只要：

auto worker = CreateWorker(staticInstanceA); // Note no `&' 

这使用了auto和简单的decltype，这两个C++ 11特性都是Intel C++编译器在v12支持的特性（尽管我没有用除GCC之外的任何其他特性测试此代码）。作为一个宏，它当然有点脆弱。

See it in action!