正在初始化同时具有字符串和int(like）类型的模板类的静态成员

我正在尝试实现一个监视器类来处理多线程。我必须使用Visual Studio 2010，所以我没有c++11。我可以简单地通过创建全局变量来实现这一点，每个全局变量对应我在线程间读/写的每种类型的值，并为每个值使用互斥锁，这很简单，但更乏味。

所以我想慢慢来，在课堂上实现监视器的概念。在某种程度上，这项工作已经"完成"了，因为数据类型是float或int，但我想更进一步，实现monitor类，以支持C标准类型和C++类，例如字符串。

我的方法是让静态成员在线程之间作为共享内存工作，这样我唯一需要做的就是在两个线程中实例化类，然后我就可以正确地设置IPC了。

问题是…我必须初始化静态成员，但我无法使其工作，因为字符串和int类型(int、float等(的初始化方式不同。

这是我尝试做的：

template<class T>
class Monitor : protected Mutex {
public:
    Monitor(bool Verbose);
    ~Monitor();
    T read(DWORD wait_time=INFINITE);
    void write(T value, DWORD wait_time=INFINITE);
    //friend void operator= (Monitor& m1, Monitor& m2);
private:
    static T container;
};
template<class T>
T Monitor<T>::container = (typeid(T) == typeid(string) ? "" : 0);

如果我只声明了CCD_ 1或CCD_。宣布两者都让我陷入error C2440: 'initializing' : cannot convert from 'const char *' to 'int'。

此外，在类中实现这种进程间通信概念的最佳方法是什么？

到目前为止的完整代码：

monitor.cpp:

#include "monitor.h"
using namespace std;
HANDLE Mutex::hMutex = nullptr;
unsigned int Mutex::counter = 0;
Mutex::Mutex(bool V) {
    Verbose = V;
    if(hMutex == nullptr) {
        if(Verbose) cout << "Creating mutexn";
        hMutex = CreateMutex(
            NULL,
            FALSE, 
            (LPCWSTR) "CONTMUTEX");
            counter++;
    }
    else{
        if(Verbose) cout <<"Mutex already createdn";
        counter++;
    }
}
Mutex::~Mutex() {
    counter--;
    if(counter == 0) {
        if(Verbose) cout << "Destroying mutexn";
        CloseHandle(hMutex);
    }
    else {
        if(Verbose) cout << "Awaiting closure of all instances of Mutexn";
    }
}
/*void operator= (Monitor& m1, Monitor& m2) {
    m1.write(m2.read());
}*/

monitor.h:

#ifndef MONITOR_INC
#define MONITOR_INC
//#include <vector>
#include <Windows.h>
#include <iostream>
using namespace std;
enum verb{VERB_OFF, VERB_ON};
class Mutex {
public:
    Mutex(bool Verbose);
    ~Mutex();
protected:
    bool Verbose;
    static HANDLE hMutex;
    static unsigned int counter;
};
template<class T>
class Monitor : protected Mutex {
public:
    Monitor(bool Verbose);
    ~Monitor();
    T read(DWORD wait_time=INFINITE);
    void write(T value, DWORD wait_time=INFINITE);
    //friend void operator= (Monitor& m1, Monitor& m2);
private:
    static T container;
};
template<class T>
T Monitor<T>::container = (typeid(T) == typeid(string) ? "" : 0);
template<class T>
Monitor<T>::Monitor(bool Verbose) : Mutex(Verbose) {
    if(Verbose) cout << "Monitor Constructorn";
}
template<class T>
Monitor<T>::~Monitor() {
    if(Verbose) cout << "Monitor Destructorn";
}
template<class T>
T Monitor<T>::read(DWORD wait_time) {
    T ret_val;
    WaitForSingleObject(hMutex, wait_time);
    ret_val = container;
    ReleaseMutex(hMutex);
    return ret_val;
}
template<class T>
void Monitor<T>::write(T value, DWORD wait_time) {
    WaitForSingleObject(hMutex, wait_time);
    container = value;
    ReleaseMutex(hMutex);
}
//void operator= (Monitor& m1, Monitor& m2);
#endif

main.cpp用于测试：

#include "monitor.h"
#include <string>
#include <sstream>
int main() {
    Mutex pMutex1(VERB_ON);
    Mutex pMutex2(VERB_ON);
    Mutex pMutex3(VERB_ON);
    Monitor<int> pMonitor1(VERB_ON);
    cout << pMonitor1.read() << "n";
    pMonitor1.write(20);
    cout << pMonitor1.read() << "n";
    Monitor<string> pMonitor2(VERB_ON);
    cout << pMonitor2.read() << "n";
    pMonitor2.write("TURN DOWN FOR WHAT");
    cout << pMonitor2.read() << "n";
    return 0;
}

我必须为任何不好的做法事先道歉。自从我上一次用C++编码以来，已经有8个月了，我正借此机会为我的C++编码技能擦去一些灰尘。

编辑1

由于某种原因，T Monitor<T>::container = ( (typeid(T) == typeid(string)) ? "" : 0);实际上不适用于int，只适用于string。