一个C++运算符重载的问题

[baickl]

#include <windows.h>
#include <iostream>

using namespace std;

class test//test可以作为char*类型的参数
{
public:

test(){ i=0;}
test(const test&t):i(t.i){}

char* i;

//下面两个操作符的重载是为了让test像char*一样的使用
operator char*(){return i;}
operator const char*()const{return i;}
};

void showmsg(char*t){MessageBox(0,t,"",MB_OK);}

template <typename T> class Test//Test可以作为类型为T的参数
{
T t;
public:

Test(const T& _t):t(_t){}

//下面两个操作符的重载是为了让Test像test一样的使用
operator T(){return t;}

operator const T&()const{return t;}
};


void main()
{
test t;
char *ssss="我是中国人";
t.i=ssss;

Test<test> ss(t);
showmsg(ss); //在这里，调用时却实失败了，不知道有什么其他办法
}

[baickl]

如何特化呢？

[xlsue]

#include <windows.h>
#include <iostream>

using namespace std;

class test//test可以作为char*类型的参数
{
public:

test(){ i=0;}
test(const test&t):i(t.i){}

char* i;

//下面两个操作符的重载是为了让test像char*一样的使用
operator char*(){return i;}
operator const char*()const{return i;}
};

void showmsg(char*t){MessageBox(0,t,"",MB_OK);}

template <typename T>
class Test //Test可以作为类型为T的参数
{
T t;
public:

Test(const T& _t):t(_t){}

//下面两个操作符的重载是为了让Test像test一样的使用
operator T(){return t;}

operator const T&()const{return t;}
};

template <>
class Test<test>
{
test t;
public:

Test(const test& _t):t(_t){}

//下面两个操作符的重载是为了让Test像test一样的使用
operator char*(){return t;}

operator const char*()const{return t;}
};



void main()
{
test t;
char *ssss="我是中国人";
t.i=ssss;

Test<test> ss(t);
showmsg(ss); //在这里，调用时却实失败了，不知道有什么其他办法
}

[xiaocai0001]

很简单的一个办法.
调用showmsg()时, 进行一下显式的类型转换

showmsg(ss);
改为:
showmsg(static_cast<test>(ss));
或直接
showmsg((test)ss);
就可以了.

[baickl]

to 空明流传：

你的方法可以解决部分情况，但是像下面就不行了。

#include <windows.h>
#include <iostream>

using namespace std;

class test//test可以作为char*类型的参数
{
public:

test(){ i="";}
test(const test&t):i(t.i){}

string i;

//下面两个操作符的重载是为了让test像char*一样的使用
operator string(){return i;}
operator const string&()const{return i;}
};

void showmsg(const string& t){cout<<t.c_str()<<endl;}

template <typename T> class Test//Test可以作为类型为T的参数
{
T t;
public:

Test(const T& _t):t(_t){}

//下面两个操作符的重载是为了让Test像test一样的使用
//operator T(){return t;}

operator const T&()const{return t;}

template <class T2>
operator T2 ()
{
return (T2)t;
}
};


void main()
{
test t;
t.i="我是中国人";

Test<test> ss(t);

showmsg(ss); //在这里，调用时却实失败了，不知道有什么其他办法
}



不知道你还有什么好的办法。还有介绍我两本template方面的书吧！！需要补充这方面的知识了。

[baickl]

to xiaocai0001(萧筱雨)：
不知道你是不是下面这个意思。可是下面的这个试验了也是不行的！

#include <windows.h>
#include <iostream>

using namespace std;

class test//test可以作为char*类型的参数
{
public:

test(){ i="";}
test(const test&t):i(t.i){}

string i;

//下面两个操作符的重载是为了让test像char*一样的使用
operator string(){return i;}
operator const string&()const{return i;}
};

void showmsg(const string& t){cout<<t.c_str()<<endl;}

template <typename T> class Test//Test可以作为类型为T的参数
{
T t;
public:

Test(const T& _t):t(_t){}

//下面两个操作符的重载是为了让Test像test一样的使用
//operator T(){return t;}

operator const T&()const{return t;}

template <class T2>
operator T2 ()
{
return (T2)t;
}
};


void main()
{
test t;
t.i="我是中国人";

Test<test> ss(t);

showmsg(static_cast<test>(ss)); //在这里，调用时却实失败了，不知道有什么其他办法
}

[xiaocai0001]

上面的程序也可以运行的啊~

不过我不是那个意思, 我说的是你最初的代码, 其他的都不需要修改
只需要改动主函数中调用showmsg()时的参数就可以了.

主函数写成如下:
void main()
{
test t;
char *ssss="我是中国人";
t.i=ssss;

Test<test> ss(t);
showmsg(static_cast<test>(ss));
}

[csucdl]

上面的方法我试过了， 完全正确啊

[逸学堂]

编译器不允许用户进行连续两次自定义转型转换。
去掉一组隐士类型转换操作符即可！

[baickl]

to xiaocai0001(萧筱雨) :

我要的是对所有的类型都是能进行正确的操作

比如 类C1有类型重载符T1，C2有类型重载符C1，那么我希望
调用C2就相当于调用C1,调用C1就相当于调用T1。。

比如说 void Invoke(T1);

现有C2 c2;
我希望Invoke(c2)也是同时正确的。而不是针对个别情况！

[baickl]

to ugg(逸学堂(exuetang.net)) :

能具体说说吗？

[lingjingqiu]

using namespace std;

class test//test可以作为char*类型的参数
{
public:

test(){ i="";}
test(const test&t):i(t.i){}

string i;

//注释掉这个
//operator string(){return i;}

operator const string&()const{return i;}
};

void showmsg(const string& t){cout<<t.c_str()<<endl;}

template <typename T> class Test//Test可以作为类型为T的参数
{
T t;
public:

Test(const T& _t):t(_t){}

//下面两个操作符的重载是为了让Test像test一样的使用
//operator T(){return t;}

operator const T&()const{return t;}

template <class T2>
operator T2 ()
{
return (T2)t;
}
};


void main()
{
test t;
t.i="我是中国人";

Test<test> ss(t);

showmsg(ss);// 把static_cast注释掉

}

该返回引用的时候，就不要返回对象！

[xiaocai0001]

比如 类C1有类型重载符T1，C2有类型重载符C1，那么我希望
调用C2就相当于调用C1,调用C1就相当于调用T1。。
-------

这根本就是一个不合逻辑的要求嘛.

像这样无限传递下去的关系, 那类型转换不成了乱七八糟的了?

比如一个string类型可以转换成char*类型
而char*类型是一个地址, 可以转换成long类型
long类型又可以转换为double类型.
如果编译器能够进行你所描述的那样隐式传递的类型自动转换.
那最后就是一个string类型可以隐式的转换为double类型?
这个合理么?
那C++还叫什么强类型的语言啊.
直接用一个通用的数据类型, 像JavaScript那样, 只需要定义一个var aa, 可以做任意类型使用了.

[lingjingqiu]

楼上的星星误会了，人家要的是有限支持隐式变换传递。

[baickl]

to xiaocai0001(萧筱雨)：

别急着指责。。你没有明白我的意思。。

[xiaocai0001]

确实还晕乎着呢~~

[baickl]

to xiaocai0001(萧筱雨):

我也晕乎着！！呵呵！！先谢谢了！

[baickl]

就此结贴，问题已经是解决了。！

虽然没有想象中那么好。但是还是感谢各位！

[foochow]

#include <windows.h>
#include <iostream>
using namespace std;
class test
{
public:
test(){ i=0;}
test(const test&t):i(t.i){}
char* i;
operator char*(){return i;}
operator const char*()const{return i;}
};
void showmsg(char*t){MessageBox(0,t,"test",MB_OK);}
template <typename T>
class Test:public test
{
T t;
public:
Test(const T& _t):t(_t){}
operator T(){return t;}
operator const T&()const{return t;}
};
void main()
{
test t;
char *ssss="我是中国人";
t.i=ssss;
Test<test> ss(t);
showmsg(ss);
}

[foochow]

晕...这么快...呵呵

[xiaocai0001]

哈哈~

楼上的没赶上~~

^_^