疑惑:类template operator函数如何调用

[__lhy]

class DBComm
{ 
     ...
     template<typename T>
     T* operator[](DBTableType op)
     {
       std::map<DBTableType,DBTableOperator*>::iterator it=mapOfOperator.find(op);
       if(it!=mapOfOperator.end())
       {
         return dynamic_cast<T*>(it->second);
       }
       return NULL;
     }
     ...
};

请问怎么调用operator[]

[__lhy]

引用 1 楼 xihu1364 的回复:

DBComm dbconn; T* pT = dbconn[op]<T>; 猜的

错的

[__lhy]

只能这样调用吗 DBComm::Instance().operator [] <MyInfoOperator>(DBComm::MyInfo)->New(0);

[版主大哥]

你改一下

template<typename T>//弄到这里来
class DBComm
{      
    ...
     T* Func(DBTableType op)
     {
       std::map<DBTableType,DBTableOperator*>::iterator it=mapOfOperator.find(op);
       if(it!=mapOfOperator.end())
       {
         return dynamic_cast<T*>(it->second);
       }
       return NULL;
     }
     ...
};

调用是 DBComm<T> dbconn; T* pT = dbconn[op]; //ok

[版主大哥]

上面没弄好

template<typename T>//弄到这里来
class DBComm
{      
    ...
     T* operator[](DBTableType op)
     {
       std::map<DBTableType,DBTableOperator*>::iterator it=mapOfOperator.find(op);
       if(it!=mapOfOperator.end())
       {
         return dynamic_cast<T*>(it->second);
       }
       return NULL;
     }
     ...
};

调用是 DBComm<T> dbconn; T* pT = dbconn[op]; //ok

[__lhy]

引用 5 楼 xihu1364 的回复:

上面没弄好

template<typename T>//弄到这里来
class DBComm
{      
    ...
     T* operator[](DBTableType op)
     {
       std::map<DBTableType,DBTableOperator*>::iterator it=mapOfOperator.find(op);
       if(it!=mapOfOperator.end())
       {
         return dynamic_cast<T*>(it->second);
       }
       return NULL;
     }
     ...
};

调用是 DBComm<T> dbconn; T* pT = dbconn[op]; //ok

跟我的本意不符合

[版主大哥]

原因是：你是想泛型函数，但是这个函数是一个特殊的函数operator[]，具体为什么不能泛型，要去google了，反正在代码中，怎么试都编译不过。 所以就将类泛型，这样才能编译通过.

[__lhy]

引用 7 楼 xihu1364 的回复:

原因是：你是想泛型函数，但是这个函数是一个特殊的函数operator[]，具体为什么不能泛型，要去google了，反正在代码中，怎么试都编译不过。 所以就将类泛型，这样才能编译通过.

是的 类模板自然是可以的 其实不重载[] 写个函数也是可以的 问题就是操作符模板函数调用

[版主大哥]

引用 8 楼 qq752923276 的回复:

[quote=引用 7 楼 xihu1364 的回复:] 原因是：你是想泛型函数，但是这个函数是一个特殊的函数operator[]，具体为什么不能泛型，要去google了，反正在代码中，怎么试都编译不过。 所以就将类泛型，这样才能编译通过.

是的 类模板自然是可以的 其实不重载[] 写个函数也是可以的 问题就是操作符模板函数调用 [/quote] 泛型函数就好办了

class DBComm
{      
public:
	template<typename T>
	T* Func(int op)     
	{               
		return NULL;     
	}    
};

//main中调用
DBComm db;
int* p = db.Func<int>(3);

[__lhy]

引用 9 楼 xihu1364 的回复:

[quote=引用 8 楼 qq752923276 的回复:] [quote=引用 7 楼 xihu1364 的回复:] 原因是：你是想泛型函数，但是这个函数是一个特殊的函数operator[]，具体为什么不能泛型，要去google了，反正在代码中，怎么试都编译不过。 所以就将类泛型，这样才能编译通过.

是的 类模板自然是可以的 其实不重载[] 写个函数也是可以的 问题就是操作符模板函数调用 [/quote] 泛型函数就好办了

class DBComm
{      
public:
	template<typename T>
	T* Func(int op)     
	{               
		return NULL;     
	}    
};

//main中调用
DBComm db;
int* p = db.Func<int>(3);

[/quote] 这个会哦

[版主大哥]

你硬是要泛型重载操作符函数，为什么不可以，那就去google，找到原因告诉下我。

[__lhy]

google后才来提问的

[taodm]

楼主这属于滥用语法糖，并且自寻烦恼了。

[版主大哥]

那我们一起坐等高手解答

[ri_aje]

非得要用的话，这么写。

d.operator[]<type>(...);

返回类型是无法自动推导的，只能显示提供。 显示提供的语法放在操作符上就很复杂。

[lm_whales]

DBComm mm; DBTableType op = DBTableType(.......)； mm[op];//错误 //typedef int Type; Type* op = mm[op];//应该没问题 Type x; try{ //防止mm[op]==NULL mm[op] = &x; //应该没问题 } catch(...){ ..... } 这里的问题转换为，如何保证class DBComm，能够正确实现。

[__lhy]

引用 15 楼 ri_aje 的回复:

非得要用的话，这么写。

d.operator[]<type>(...);

返回类型是无法自动推导的，只能显示提供。 显示提供的语法放在操作符上就很复杂。

这种写法3L已经给出了

[__lhy]

引用 16 楼 lm_whales 的回复:

DBComm mm; DBTableType op = DBTableType(.......)； mm[op];//错误 //typedef int Type; Type* op = mm[op];//应该没问题 Type x; try{ //防止mm[op]==NULL mm[op] = &x; //应该没问题 } catch(...){ ..... } 这里的问题转换为，如何保证class DBComm，能够正确实现。

不解

[__lhy]

引用 13 楼 taodm 的回复:

楼主这属于滥用语法糖，并且自寻烦恼了。

你说的对吧，改为模板函数了

[mujiok2003]

struct DBComm
{
	template<typename T>
	T* operator[](int v)
	{
		return new T(v);
	}
};


int main()
{
	DBComm dbc;
	double* v = dbc.operator[]<double>(10);
	delete v;

}

[一入程序深似海]

DBComm不是模板类吗？ 这样用好奇怪。 写过简单的vector实现吗？里面就有operator[]的操作，类似的用法吧。