C++ C+中迭代器上的运算符+；

我正在将一个旧的代码库移植到OSX

我有以下代码片段：

FxLayerList::iterator lastVisible = NULL;
for (FxLayerList::iterator iter = mBranch.begin(); iter != mBranch.end(); iter++) {
    if ( (*iter)->IsVisible() && !(*iter)->IsBypass()) {
        lastVisible = iter;
    }
}
if (lastVisible != NULL && (*lastVisible)->GetGeneratedImage()) {

我得到一个错误，上面写着：

error:与“operator！=”不匹配在'lastVisible！=0'

我不明白，我以为是这样的和==，等等是标准操作。为什么编译器会抱怨

更新：我试图理解对象的比较。如果代码如下所示：

FxBool FxLayerList::Contains(FxLayer *layer) const
{
for (FxLayerList::const_iterator iter=this->begin(); iter != this->end(); iter++)
{
    if ((*iter) == layer) {
        return true;
    }   
}
return false;
}

错误：错误：ISOC++表示这些是模棱两可的，即使第一个最坏的转换比第二个最坏的转换好：

我缺少的核心概念是什么

更新2：

// FxSmartPtr is a smart pointer that is also typed for each class, avoiding the need for any casting.
// Setting an FxSmartPtr to NULL actually kills the memory that it's pointing to as well.
template <class eachClass>
class FxSmartPtr
{
public:
// Construction

// Default constructor makes an empty container.
FxSmartPtr(void) : mPtr(NULL) {}

// Construction with a ptr adds one reference to it.
FxSmartPtr(eachClass *ptr) : mPtr(ptr) { this->Reference(); }

// Copy construction means that both smart pointers end up with a reference to the object.
FxSmartPtr(const FxSmartPtr & inPtr) :mPtr(NULL) { FrAssignRef(mPtr,(eachClass *)inPtr.mPtr); }

// Default construction
FxSmartPtr(FxConstructArg cons) { if (cons == FcNew) mPtr = new eachClass(); }
FxSmartPtr(FxConstructArg cons,eachClass *ptr) { if (cons == FcNew) mPtr = ptr; }

// Destructor removes only the one reference that we own.
~FxSmartPtr() { this->Dispose(); }


// Most important and common use is via assignment. References are always safely balanced.

// AssignReference safely replaces one reference counted ptr with another. 
static inline eachClass * FrAssignRef(eachClass *& to, eachClass * from)
    { if (from) from->AddReference(); if (to) to->RemoveReference(); to = from; return to; }

// If you assign a pointer to this object we add one reference count to it.
const FxSmartPtr<eachClass> & operator = (const eachClass *ptr)
    { FrAssignRef(mPtr,(eachClass *)ptr); return *this; }

// Replace our referenced object with a reference added to the incoming one.
const FxSmartPtr<eachClass> & operator = (const FxSmartPtr & inPtr)
    { FrAssignRef(mPtr,(eachClass *)inPtr.mPtr); return *this; }

// Assignment to a dumb pointer takes/gives no references.
operator eachClass * (void) const
    { return mPtr; }
eachClass * operator->(void)
    { if (mPtr != NULL) if (mPtr->GetRefCount() < 1 || mPtr->GetRefCount() > 10000) ASSERT(0); return mPtr; }
const eachClass * operator->(void) const
    { if (mPtr != NULL) if (mPtr->GetRefCount() < 1 || mPtr->GetRefCount() > 10000) ASSERT(0); return mPtr; }


// Explicit assignment and object transfers

// Get() - return ptr with no reference
eachClass * Get(void) const
    { return mPtr; }
eachClass * GetPtr(void)
    { return mPtr; }

// Own() - return ownership with ptr
eachClass * Own(void)
    { if (mPtr) mPtr->AddReference(); return mPtr; }

// Set() - we take our own reference on your object
FxSmartPtr<eachClass> & Set(eachClass * ptr)
    { FrAssignRef(mPtr, ptr); return *this; }

// Take() - you give us your reference
FxSmartPtr<eachClass> & Take(eachClass * ptr)
    { FrDispose(mPtr); mPtr = ptr; return *this; }


// Comparison operators compare the pointers contained in each
FxBool operator == (const FxSmartPtr & inPtr) const
    { return (mPtr == inPtr.mPtr); }
FxBool operator == (const eachClass * inPtr) const
    { return (mPtr == inPtr); }
FxBool operator != (const FxSmartPtr & inPtr) const
    { return (mPtr != inPtr.mPtr); }
FxBool operator != (const eachClass * inPtr) const
    { return (mPtr != inPtr); }

// Reference() and Dispose() change the normal reference count. If you use these then
// you end up having to count references externally.

// Safely take a reference if the ptr is not nil
void Reference(void) { if (mPtr != NULL) mPtr->AddReference(); }
// Safely dispose one reference count.
void Dispose(void) { if (mPtr != NULL)
    // JASON/INDIE - SLACKMOEHRLE@GMAIL.COM
    // { ULONG refs = mPtr->GetRefCount(); mPtr->RemoveReference(); if (refs <= 1) mPtr = NULL; } }
    { FxUInt32 refs = mPtr->GetRefCount(); mPtr->RemoveReference(); if (refs <= 1) mPtr = NULL; } }

protected:

    eachClass *mPtr;
};

//FxSmartPtr是一个智能指针，也为每个类键入，避免了任何强制转换的需要。
//将FxSmartPtr设置为NULL实际上也会杀死它所指向的内存。
模板
类FxSmartPtr
{
公众：
//建筑
//默认构造函数生成一个空容器。
FxSmartPtr（void）：mPtr（NULL）{}
//带有ptr的构造为其添加了一个引用。
FxSmartPtr（eachClass*ptr）：mPtr（ptr）{this->Reference（）；}
//复制构造意味着两个智能指针都以对对象的引用结束。
FxSmartPtr（const FxSmartPtr&inPtr）：mPtr（NULL）{FrAssignRef（mPtr，（eachClass*）inPtr.mPtr）；}
//默认构造
FxSmartPtr（FxConstructArg cons）{if（cons==FcNew）mPtr=new eachClass（）；}
FxSmartPtr（FxConstructArg cons，eachClass*ptr）{if（cons==FcNew）mPtr=ptr；}
//析构函数只删除我们拥有的一个引用。
~FxSmartPtr（）{this->Dispose（）；}
//最重要和最常用的是通过赋值。引用总是安全平衡的。
//AssignReference安全地将一个引用计数的ptr替换为另一个。
静态内联eachClass*FrAssignRef（eachClass*&收件人，eachClass*发件人）
{if（from）from->AddReference（）；if（to）to->RemoveReference（）；to=from；return to；}
//如果你给这个对象分配了一个指针，我们会给它添加一个引用计数。
常量FxSmartPtr和运算符=（常量eachClass*ptr）
{FrAssignRef（mPtr，（eachClass*）ptr）；返回*this；}
//用添加到传入对象的引用替换引用对象。
常量FxSmartPtr和运算符=（常量FxSmartPtr和inPtr）
{FrAssignRef（mPtr，（eachClass*）inPtr.mPtr）；返回*this；}
//对哑指针的赋值不接受/不提供引用。
运算符eachClass*（void）常量
{返回mPtr；}
每个类*运算符->（无效）
{if（mPtr！=NULL）if（mPtr->GetRefCount（）<1 | mPtr->GetRefCount（）>10000）断言（0）；返回mPtr；}
常量eachClass*运算符->（无效）常量
{if（mPtr！=NULL）if（mPtr->GetRefCount（）<1 | mPtr->GetRefCount（）>10000）断言（0）；返回mPtr；}
//显式赋值与对象转移
//Get（）-返回不带引用的ptr
每个类*获取（无效）常量
{返回mPtr；}
每个类*GetPtr（无效）
{返回mPtr；}
//Own（）-使用ptr返回所有权
每个类*自己的（无效）
{if（mPtr）mPtr->AddReference（）；返回mPtr；}
//Set（）-我们对您的对象进行自己的引用
FxSmartPtr&Set（每个类*ptr）
{FrAssignRef（mPtr，ptr）；返回*this；}
//Take（）-你给我们你的推荐信
FxSmartPtr&Take（每个类*ptr）
{frdespose（mPtr）；mPtr=ptr；返回*this；}
//比较运算符比较每个表达式中包含的指针
FxBool运算符==（常量FxSmartPtr和inPtr）常量
{return（mPtr==inPtr.mPtr）；}
FxBool运算符==（常量eachClass*inPtr）常量
{return（mPtr==inPtr）；}
FxBool运算符！=（常量FxSmartPtr和inPtr）常量
{return（mPtr！=inPtr.mPtr）；}
FxBool运算符！=（常量eachClass*inPtr）常量
{return（mPtr！=inPtr）；}
//Reference（）和Dispose（）更改正常引用计数。如果使用这些
//你最终不得不从外部统计引用。
//如果ptr不是零，则安全地获取参考
无效引用（void）{if（mPtr！=NULL）mPtr->AddReference（）；}
//安全地处理一个引用计数。
void Dispose（void）{if（mPtr！=NULL）
//詹森/独立-SLACKMOEHRLE@GMAIL.COM
//{ULONG refs=mPtr->GetRefCount（）；mPtr->RemoveReference（）；if（refs GetRefCount（）；mPtr->RemoveReference（）；if（refs看起来，
lastVisible
是一个对象，而不仅仅是一个指针。如果将某个对象与某个对象进行比较，则它必须具有适当的运算符

也许这可以编译

FxLayerList::iterator lastVisible = mBranch.end();
for (FxLayerList::iterator iter = mBranch.begin(); iter != mBranch.end(); iter++)
{
    if ( (*iter)->IsVisible() && !(*iter)->IsBypass())
    {
       lastVisible = iter;
    }
}
if (lastVisible != mBranch.end() && (*lastVisible)->GetGeneratedImage())
{ ...

或者，如果
FxLayerList
只是指向
FxLayer
的指针的集合，这将更简单：

FxLayer *lastVisible = NULL;
for (FxLayerList::iterator iter = mBranch.begin(); iter != mBranch.end(); iter++)
{
    if ( (*iter)->IsVisible() && !(*iter)->IsBypass())
    {
        lastVisible = *iter;
    }
}
if (lastVisible != NULL && lastVisible->GetGeneratedImage())
{ ...

更新的答案：请参阅下面我的评论。问题（编译器错误消息）可以通过从“智能”指针显式检索指针来解决：

看起来，
lastVisible
是一个对象，而不仅仅是一个指针。如果将某个对象与某个对象进行比较，那么它必须具有相应的运算符

也许这可以编译

FxLayerList::iterator lastVisible = mBranch.end();
for (FxLayerList::iterator iter = mBranch.begin(); iter != mBranch.end(); iter++)
{
    if ( (*iter)->IsVisible() && !(*iter)->IsBypass())
    {
       lastVisible = iter;
    }
}
if (lastVisible != mBranch.end() && (*lastVisible)->GetGeneratedImage())
{ ...

或者，如果
FxLayerList
只是指向
FxLayer
的指针的集合，这将更简单：

FxLayer *lastVisible = NULL;
for (FxLayerList::iterator iter = mBranch.begin(); iter != mBranch.end(); iter++)
{
    if ( (*iter)->IsVisible() && !(*iter)->IsBypass())
    {
        lastVisible = *iter;
    }
}
if (lastVisible != NULL && lastVisible->GetGeneratedImage())
{ ...

更新的答案：请参阅下面我的评论。问题（编译器错误消息）可以通过从“智能”指针显式检索指针来解决：

标准运算符可以重载以支持直接比较对象，但它们不知道要比较什么（我认为默认行为是简单地比较对象的地址，但您的错误似乎与此相反）

无论如何，这似乎是一个非常相似的问题

在您的课堂上，您可能应该添加类似Alexander建议的内容：

int Date :: Compare (const Date& d) {

  if (year<d.year) {
    return -1;
  }
}

bool operator == (const Date& d) const {
   return !Compare(d);
}

int-Date:：Compare（const-Date&d）{
如果（year标准运算符可以重载以支持直接比较对象，但开箱即用，它们不知道要比较什么（我认为默认行为是简单地比较对象的地址，但您的错误似乎与此相反）

不管怎么说，这似乎是一个问题