编译不了？提示 overloads have similar conversions

[zhucaiguai]

我写了两个函数，如下：
BOOL operator == (const myString& str) const
{
return str == pszString;
}

BOOL operator != (const myString& str) const
{
return str != pszString;
}

编译通不过，提示如下：
error C2666: 'myString::operator !=' : 3 overloads have similar conversions


求助啦~

[心中那自由的世界]

#include <string>

class T
{
public:
explicit T() {}
explicit T( const T & t ) { printf("In T(t)\n"); }
T &operator=( const T &t ) { printf("In =(t)\n");}
bool operator==(const T& t) { return t.value == value; }
bool operator!=(const T& t) { return t.value != value; }

private:
std::string value;
};

int main()
{
T a;
T b;
if (a == b)
;
return 0;
}

我这样写没有问题啊?是不是你的编绎器不支持?

[zhucaiguai]

我用的是VC2005，你用的是什么啊？

[ckt]

BOOL operator == (const myString& str) const
{
return str == pszString;
}

BOOL operator != (const myString& str) const
{
return str != pszString;
}


你myString类有重载!= 和 == 么

[真相重于对错]

形参表过于类似，无法解析多义性。

[真相重于对错]

类定义
？？？

[心中那自由的世界]

我用vs2005编了,也没有问题,还是把你完整的类贴出来吧..

[真相重于对错]

return str != pszString;
pszString 是什么类型？？

[shanhqk]

BOOL operator == (const myString& str) const
{
return str == pszString;
}

BOOL operator != (const myString& str) const
{
return str != pszString;
}
我认为==和!=不能这样定义。
因为LZ需要使用==和!=，但是LZ明显的是为myString类定义这两种操作符的。
LZ必须为其中的成员变量来写==和!=，而不能直接使用这两个。

[zhucaiguai]

/*
Free Download Manager Copyright (c) 2003-2007 FreeDownloadManager.ORG
*/



#ifndef __FXS_STRING_H_
#define __FXS_STRING_H_

#include <tchar.h>
#include <stdio.h>

struct fsString
{
LPTSTR pszString;

fsString ()
{
pszString = NULL;
}

~fsString ()
{
if (pszString)
delete [] pszString;
}

fsString (const fsString& str)
{
pszString = NULL;
*this = str.pszString;
}

fsString (LPCTSTR str)
{
pszString = NULL;
*this = str;
}

LPCTSTR operator = (LPCTSTR pszStr)
{
if (pszString)
{
delete [] pszString;
pszString = NULL;
}

if (pszStr)
{
pszString = new TCHAR [_tcslen (pszStr) + 1];
if (pszString)
_tcscpy ( pszString, pszStr );
}

return pszString;
}

fsString& operator = (const fsString& str)
{
*this = str.pszString;
return *this;
}

LPCTSTR operator += (LPCTSTR pszStr)
{
if (pszStr == NULL)
return pszString;

if ( pszString )
{
LPTSTR pszOld = pszString;

pszString = new TCHAR [ _tcslen (pszString) + _tcslen (pszStr) + 1 ];
_tcscpy ( pszString, pszOld );
_tcscat ( pszString, pszStr );

delete [] pszOld;
}
else
{
*this = pszStr;
}

return pszString;
}

LPCTSTR operator += (char c)
{
char sz [2];
sz [0] = c; sz [1] = 0;
return *this += sz;
}

fsString operator + (LPCTSTR psz) const
{
fsString str = *this;
str += psz;
return str;
}

BOOL operator == (const fsString& str) const
{
return str == pszString;
}

BOOL operator != (const fsString& str) const
{
return str != pszString;
}

BOOL operator == (LPCTSTR pszStr) const
{
if (pszString == NULL || pszStr == NULL)
return pszStr == pszString;

return _tcscmp ( pszString, pszStr ) == 0;
}

void clear ()
{
if (pszString)
{
delete [] pszString;
pszString = NULL;
}
}

void ncpy (LPCSTR pszStr, int nch)
{
alloc (nch);
strncpy (pszString, pszStr, nch);
}

void alloc (int nch)
{
clear ();
pszString = new char [nch+1];
pszString [nch] = 0;
}

BOOL operator != (LPCSTR pszStr) const
{
return !(*this == pszStr);
}

operator LPTSTR () const
{
return pszString;
}

int Length ()
{
if (pszString)
return _tcslen (pszString);
else
return 0;
}

BOOL IsEmpty ()
{
return pszString == NULL || *pszString == 0;
}

int GetLength () {return Length ();}

void Replace (LPCSTR , LPCSTR ) {}

void Format (LPCSTR pszFormat ...)
{
LPSTR psz = new char [100000];
va_list ap;
va_start (ap, pszFormat);
vsprintf (psz, pszFormat, ap);
va_end (ap);
*this = psz;
delete [] psz;
}
};

#endif

完整代码如上~

[心中那自由的世界]

BOOL operator == (const myString& str) const
{
return str.pszString == pszString;
}

BOOL operator != (const myString& str) const
{
return str.pszString != pszString;
}

这样才对.

[ckt]

BOOL operator == (const fsString& str) const
{
return str == pszString;
}

BOOL operator != (const fsString& str) const
{
return str != pszString;
}

// 就是因为不能直接比较，所以你才要重载== 和 ！=
// 所以你不能直接用str == pszString;和str != pszString;

[shanhqk]

BOOL operator == (const fsString& str) const
{
return this.pszString == str.pszString;
}

BOOL operator != (const fsString& str) const
{
return str.pszString != this.pszString;
}

[ckt]

stccmp(pszString, str.pszString)
比较两个字符串是否相等

你这个结构其他有的地方写的很乱
可以去网上在找点资料参考

[ckt]

to：shanhqk(山)

return this.pszString == str.pszString;

字符串比较应该是比较内容，不是首地址吧

[zhucaiguai]

编译通过，多谢楼上的兄弟~

结贴，给分，睡觉^_^

[shanhqk]

最好还是使用：_tcscpy相同的比较函数好一点，具体的我不是很清楚，LZ可以查一下。

[shanhqk]

BOOL operator == (const myString& str) const
{
return str == pszString;
}

BOOL operator != (const myString& str) const
{
return str != pszString;
}
我认为==和!=不能这样定义。
因为LZ需要使用==和!=，但是LZ明显的是为myString类定义这两种操作符的。
LZ必须为其中的成员变量来写==和!=，而不能直接使用这两个。

BOOL operator == (const fsString& str) const
{
return this.pszString == str.pszString;
}

BOOL operator != (const fsString& str) const
{
return str.pszString != this.pszString;
}


最好还是使用：_tcscpy相同的比较函数好一点，具体的我不是很清楚，LZ可以查一下。

[shanhqk]

BOOL operator == (const myString& str) const
{
return str == pszString;
}

BOOL operator != (const myString& str) const
{
return str != pszString;
}
我认为==和!=不能这样定义。
因为LZ需要使用==和!=，但是LZ明显的是为myString类定义这两种操作符的。
LZ必须为其中的成员变量来写==和!=，而不能直接使用这两个。

BOOL operator == (const fsString& str) const
{
return this.pszString == str.pszString;
}

BOOL operator != (const fsString& str) const
{
return str.pszString != this.pszString;
}


最好还是使用：_tcscpy相同的比较函数好一点，具体的我不是很清楚，LZ可以查一下。

[vocanicy]

楼主你的类应该没有问题，VC6下一切正常，估计和编译器对有关
MSDN中也提到不同编译器对这种情况处理不同
2005也许加强了这方面的检查


我估计是这个原因
BOOL operator != (LPCTSTR pszStr) const
BOOL operator != (const fsString& str) const

由于你写了构造函数fsString(LPCTSTR)
当与比较 LPTSTR类型进行比较的时候，编译器无知道该调用operator != (LPCTSTR pszStr)还是调用BOOL operator != (const fsString& str) const好
因为LPTSTR可以转换成LPCTSTR，也可以转换成const fsString

由于你重载了operator LPCTSTR()
如果和fsString类型比较时，编译器无知道该调用operator != (LPCTSTR pszStr)还是调用BOOL operator != (const fsString& str) const好
因为fsString可以转换成LPCTSTR，也可以转换成const fsString


建议你试试将其中一个函数去掉试试