[英]Erroneous/Incorrect C2248 error using Visual Studio 2010
我正在使用Visual Studio 2010编译器看到我认为是错误/不正确的编译器错误。 我正在从Visual Studio 2005向上移植我们的代码库,并且我遇到了之前正在构建的构造,但现在生成了C2248编译器错误。
显然,下面的代码片段已经通用化,但它是该场景的可编辑示例。 ObjectPtr<T>
C ++模板来自我们的代码库,是有问题的错误的来源。 似乎正在发生的事情是编译器在不应该生成对ObjectPtr<T>
的复制构造函数的调用时(参见下面的SomeContainer::Foo()
方法中的注释块)。 expression if the ?:
operator. 对于此代码构造,在ObjectPtr<SomeUsefulData>
上有SomeUsefulData *
的公共SomeUsefulData *
运算符,但如果是?:
运算符,则不在表达式中选择它。 相反,我在下面的块引用中得到了两个错误。
根据我对C ++的了解,这段代码应该编译。 有没有人见过这种行为? 如果没有,有人可以指出我对编译器解析规则的澄清,这可以解释为什么它在这种情况下试图生成对象的副本吗?
提前致谢,
迪伦布尔克
c:\\ projects \\ objectptrtest \\ objectptrtest.cpp(177):错误C2248:'ObjectPtr :: ObjectPtr':无法访问类'ObjectPtr'中声明的私有成员
同
[T = SomeUsefulData]
c:\\ projects \\ objectptrtest \\ objectptrtest.cpp(25):参见'ObjectPtr :: ObjectPtr'的声明
同
[T = SomeUsefulData]
c:\\ projects \\ objectptrtest \\ objectptrtest.cpp(177):错误C2248:'ObjectPtr :: ObjectPtr':无法访问类'ObjectPtr'中声明的私有成员
同
[T = SomeUsefulData]
c:\\ projects \\ objectptrtest \\ objectptrtest.cpp(25):参见'ObjectPtr :: ObjectPtr'的声明
同
[T = SomeUsefulData]
#include <stdio.h>
#include <tchar.h>
template<class T>
class ObjectPtr {
public:
ObjectPtr<T> (T* pObj = NULL, bool bShared = false) :
m_pObject(pObj), m_bObjectShared(bShared)
{}
~ObjectPtr<T> ()
{
Detach();
}
private:
// private, unimplemented copy constructor and assignment operator
// to guarantee that ObjectPtr<T> objects are not copied
ObjectPtr<T> (const ObjectPtr<T>&);
ObjectPtr<T>& operator = (const ObjectPtr<T>&);
public:
T * GetObject ()
{ return m_pObject; }
const T * GetObject () const
{ return m_pObject; }
bool HasObject () const
{ return (GetObject()!=NULL); }
bool IsObjectShared () const
{ return m_bObjectShared; }
void ObjectShared (bool bShared)
{ m_bObjectShared = bShared; }
bool IsNull () const
{ return !HasObject(); }
void Attach (T* pObj, bool bShared = false)
{
Detach();
if (pObj != NULL) {
m_pObject = pObj;
m_bObjectShared = bShared;
}
}
void Detach (T** ppObject = NULL)
{
if (ppObject != NULL) {
*ppObject = m_pObject;
m_pObject = NULL;
m_bObjectShared = false;
}
else {
if (HasObject()) {
if (!IsObjectShared())
delete m_pObject;
m_pObject = NULL;
m_bObjectShared = false;
}
}
}
void Detach (bool bDeleteIfNotShared)
{
if (HasObject()) {
if (bDeleteIfNotShared && !IsObjectShared())
delete m_pObject;
m_pObject = NULL;
m_bObjectShared = false;
}
}
bool IsEqualTo (const T * pOther) const
{ return (GetObject() == pOther); }
public:
T * operator -> ()
{ ASSERT(HasObject()); return m_pObject; }
const T * operator -> () const
{ ASSERT(HasObject()); return m_pObject; }
T & operator * ()
{ ASSERT(HasObject()); return *m_pObject; }
const T & operator * () const
{ ASSERT(HasObject()); return (const C &)(*m_pObject); }
operator T * ()
{ return m_pObject; }
operator const T * () const
{ return m_pObject; }
operator bool() const
{ return (m_pObject!=NULL); }
ObjectPtr<T>& operator = (T * pObj)
{ Attach(pObj, false); return *this; }
bool operator == (const T * pOther) const
{ return IsEqualTo(pOther); }
bool operator == (T * pOther) const
{ return IsEqualTo(pOther); }
bool operator != (const T * pOther) const
{ return !IsEqualTo(pOther); }
bool operator != (T * pOther) const
{ return !IsEqualTo(pOther); }
bool operator == (const ObjectPtr<T>& other) const
{ return IsEqualTo(other.GetObject()); }
bool operator != (const ObjectPtr<T>& other) const
{ return !IsEqualTo(other.GetObject()); }
bool operator == (int pv) const
{ return (pv==NULL)? IsNull() : (LPVOID(m_pObject)==LPVOID(pv)); }
bool operator != (int pv) const
{ return !(*this == pv); }
private:
T * m_pObject;
bool m_bObjectShared;
};
// Some concrete type that holds useful data
class SomeUsefulData {
public:
SomeUsefulData () {}
~SomeUsefulData () {}
};
// Some concrete type that holds a heap-allocated instance of
// SomeUsefulData
class SomeContainer {
public:
SomeContainer (SomeUsefulData* pUsefulData)
{
m_pData = pUsefulData;
}
~SomeContainer ()
{
// nothing to do here
}
public:
bool EvaluateSomeCondition ()
{
// fake condition check to give us an expression
// to use in ?: operator below
return true;
}
SomeUsefulData* Foo ()
{
// this usage of the ?: operator generates a C2248
// error b/c it's attempting to call the copy
// constructor on ObjectPtr<T>
return EvaluateSomeCondition() ? m_pData : NULL;
/**********[ DISCUSSION ]**********
The following equivalent constructs compile
w/out error and behave correctly:
(1) explicit cast to SomeUsefulData* as a comiler hint
return EvaluateSomeCondition() ? (SomeUsefulData *)m_pData : NULL;
(2) if/else instead of ?:
if (EvaluateSomeCondition())
return m_pData;
else
return NULL;
(3) skip the condition check and return m_pData as a
SomeUsefulData* directly
return m_pData;
**********[ END DISCUSSION ]**********/
}
private:
ObjectPtr<SomeUsefulData> m_pData;
};
int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}
构造函数和析构函数不应该具有类的模板参数:
ObjectPtr(T* pObj = NULL, bool bShared = false) :
m_pObject(pObj), m_bObjectShared(bShared)
{}
(注意缺少<T>
)
但我认为这是无关紧要的。 请参阅下面的答案......
我没有C ++标准的实际副本,但是从第102-103页的草案中 ,如果expression ? E1 : E2
,那么声明是不正确的expression ? E1 : E2
expression ? E1 : E2
,T1和T2类型,如果T1和T2没有继承关系,一个是rvalue,那么,
使用该过程,确定是否可以转换第二操作数以匹配第三操作数,以及是否可以转换第三操作数以匹配第二操作数。 如果两者都可以转换,或者一个可以转换,但转换不明确,则程序格式不正确。 如果两者都不能被转换,则操作数保持不变并且如下所述执行进一步检查。 如果只能进行一次转换,则将该转换应用于所选操作数,并使用转换后的操作数代替本节其余部分的原始操作数。
这似乎表明你的语句是ObjectPtr
(因为你有一个ObjectPtr
的非显式构造函数以及operator T*
),但正如我所说,我没有实际的标准。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.