C++ 使用Visual Studio 2010时出现错误/不正确的C2248错误

我正在使用Visual Studio 2010编译器看到我认为是错误/不正确的编译器错误。我正在从VisualStudio2005向上移植我们的代码库，我遇到了一个以前构建正确但现在生成C2248编译器错误的构造

显然，下面的代码片段已经过泛型化，但它是该场景的一个可编译示例。<代码> ObjtPtR/C++ > C++模板来自我们的代码库，是问题的根源。似乎正在发生的是，编译器正在生成对

ObjectPtr

的复制构造函数的调用，而它本不应该这样做（请参见下面

SomeContainer:：Foo（）

方法中的我的注释块）。对于此代码构造，在

ObjectPtr

上有一个用于

SomeUsefulData*

的公共强制转换运算符，但如果

？：

运算符为空，则不会在真表达式中选择该运算符。相反，我在下面的块引号中得到了两个错误

根据我对C++的了解，应该编译这个代码。还有人见过这种行为吗？如果没有，有人能告诉我一个编译器解析规则的说明，解释为什么在这种情况下它试图生成对象的副本吗

提前感谢，
迪伦布尔克

Visual Studio生成输出：

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=一些有用的数据]

---

下面是该场景的一个最小的可编译示例：

#包括
#包括
模板
类ObjectPtr{
公众：
ObjectPtr（T*pObj=NULL，bool-bShared=false）：
m_对象（pObj），m_对象共享（B共享）
{}
~ObjectPtr（）
{
分离（）；
}
私人：
//私有的、未实现的复制构造函数和赋值运算符
//确保不会复制ObjectPtr对象
ObjectPtr（const ObjectPtr&）；
ObjectPtr&运算符=（const ObjectPtr&）；
公众：
T*GetObject（）
{返回m_pObject；}
常量T*GetObject（）常量
{返回m_pObject；}
布尔HasObject（）常量
{return（GetObject（）！=NULL）；}
布尔IsObjectShared（）常量
{返回m_bObjectShared；}
void ObjectShared（bool-bShared）
{m_bObjectShared=b共享；}
bool IsNull（）常量
{return！HasObject（）；}
无效附加（T*pObj，bool bShared=false）
{
分离（）；
if（pObj！=NULL）{
m_pObject=pObj；
m_bObjectShared=b共享；
}
}
无效分离（T**ppObject=NULL）
{
if（ppObject！=NULL）{
*ppObject=m_poobject；
m_pObject=NULL；
m_bObjectShared=false；
}
否则{
if（HasObject（））{
如果（！IsObjectShared（））
删除m_pObject；
m_pObject=NULL；
m_bObjectShared=false；
}
}
}
无效分离（bool-bDeleteIfNotShared）
{
if（HasObject（））{
if（bDeleteIfNotShared&！IsObjectShared（））
删除m_pObject；
m_pObject=NULL；
m_bObjectShared=false；
}
}
布尔·伊斯夸尔托（康斯特·波特）康斯特
{return（GetObject（）==pOther）；}
公众：
T*运算符->（）
{ASSERT（HasObject（））；返回m_pObject；}
常量T*运算符->（）常量
{ASSERT（HasObject（））；返回m_pObject；}
T&运算符*（）
{ASSERT（HasObject（））；返回*m_pObject；}
常量T&运算符*（）常量
{ASSERT（HasObject（））；return（const C&）（*m_pObject）；}
算子T*（）
{返回m_pObject；}
运算符常量T*（）常量
{返回m_pObject；}
运算符bool（）常量
{返回（m_pObject！=NULL）；}
ObjectPtr&运算符=（T*pObj）
{Attach（pObj，false）；返回*this；}
布尔运算符==（常数T*pOther）常数
{返回IsEqualTo（pOther）；}
布尔运算符==（T*pOther）常量
{返回IsEqualTo（pOther）；}
布尔运算符！=（常数T*pOther）常数
{返回！IsEqualTo（pOther）；}
布尔运算符！=（T*pOther）常量
{返回！IsEqualTo（pOther）；}
布尔运算符==（常量对象PTR和其他）常量
{返回IsEqualTo（other.GetObject（））；}
布尔运算符！=（常量对象ptr和其他）常量
{return！IsEqualTo（other.GetObject（））；}
布尔运算符==（int pv）常量
{return（pv==NULL）？IsNull（）：（LPVOID（m_pObject）==LPVOID（pv））；}
布尔运算符！=（整数pv）常量
{return！（*this==pv）；}
私人：
T*m_对象；
bool m_bObjectShared；
};
//一些保存有用数据的具体类型
分类一些有用的数据{
公众：
一些有用的数据（）{}
~SomeUsefulData（）{}
};
//保存堆分配的实例的某个具体类型
//一些有用的数据
类容器{
公众：
SomeContainer（SomeUsefulData*PuseulData）
{
m_pData=数据；
}
~SomeContainer（）
{
//这里没什么可做的
}
公众：
bool EvaluateSomeCondition（）
{
//假条件检查给我们一个表达式
//用于？：下面的运算符
返回true；
}
一些有用的数据*Foo（）
{
//使用？：运算符会生成一个C2248
//错误b/c试图调用副本
//ObjectPtr上的构造函数
返回EvaluateSomeCondition（）？m_pData:NULL；
/**********[讨论
#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)
   {}