STL 集合的解引用迭代器

Question

我在从 STL 集继承时遇到问题（我认为）：

这是 Prime 类：

class Prime : public set<A> {
private:
  // private data members.
public:
  // C'tor...
  void printParticularA(const int& id);
}

这里是A类：

class A : public List<B>{  
private:  
  // data members.  
  int id;
public:  
  // C'tor  
  A(const A& copy) : List<B>(copy), //copy data members  
     { // validate data and throw exceptions if needed. };

  bool operator< (const A& rhs) const{  
    return id < rhs.id;  
  }

  void printReport() const {  
    for(const B& item : *this){ item.print(); }
  }

}

现在问题来了。在下一个函数中，我想打印集合中的特定 A 对象：

void Prime::printParticularA(const int& id) {
  find(AFinder(id))->printReport();
}

我也试过这个：

void Prime::printParticularA(const int& id) {
  *(find(AFinder(id))).printReport();
}

注意：假设 B 类有 print() 方法。
注意 2：AFinder 是一个仅使用 id 数据制作虚拟 A 对象的类。

问题在于，当“find”找到对象时，它返回 const_iterator（因为 set 中的每个对象都是 const），而当我取消引用它时，我得到了对象的副本 (??) 但里面的 B 列表是空的！
'->' 版本也会出现这种情况。

现在我知道 set 不允许我更改对象，但我不打算更改对象（如您在 printReport 成员函数的声明中所见）。

感谢您对此提供的任何帮助！

编辑：谢谢大家，你们帮了我很多，尤其是学会了不该做的事情。
我解决了这个问题，但它不在集合、列表中，也没有我在这里展示的任何课程。
我的错误在于理解给我的问题（是的，这是我的家庭作业，我还是 C++ 新手）。
抱歉，如果您觉得我浪费了您的时间。
我希望我可以从您的所有经验中学习，并有朝一日帮助他人！
简而言之，谢谢！ :)

Answer 1

您的代码几乎一团糟。而且这个问题看起来并不直接与 set 或 iterator 相关，而是一般的坏事。

对于初学者来说，让你的 op

所有这些都可能使您描述的问题消失，如果没有，请发布一个完整的可编译示例，其中包含您所看到的和您期望的正确文本。

Answer 2

您的代码确实违反了 C++ 的许多规则。你为什么不这样尝试：

#include <iostream>
#include <list>
#include <map>

using namespace std;

class SimpleInt {
public:  
  int data_;

  SimpleInt(const int data): data_(data) {};
  void print() const {cout << data_ << " ";};
};

template <typename T>
class A {  
private:  
  // private data members.  
public:  
  list<T> list_of_B_; // this is for simlicity. Make getters as you need
  const int id_; // delete it or copy to map. You sholdn't change it.

  A(int id) : list_of_B_(), id_(id) {} 
  A(const A<T>& copy) : list_of_B_(copy.list_of_B_), id_(copy.id_) {} //copy data members  
  A(A<T>&& copy) : list_of_B_(::std::move(copy.list_of_B_)), id_(copy.id_) {} //move data members  

  void printReport() const {  
    for(const T& item : list_of_B_){ item.print(); }
  }

};

template <typename T>
class Prime {
private:
  // private data members.
public:
  // The main difference with your source
  map<int, T> map_of_A_; // this is for simlicity. Make getters as you need
  // C'tor...
  void printParticularA(const int& id) {
    auto it = map_of_A_.find(id);
    if (it != map_of_A_.end())
      it->second.printReport();
  }
};

int _tmain(int argc, _TCHAR* argv[])
{
  typedef A<SimpleInt> ASimpled;
  Prime<ASimpled> prime;
  ASimpled a(1);
  a.list_of_B_.push_back(SimleInt(1));
  a.list_of_B_.push_back(SimleInt(2));
  a.list_of_B_.push_back(SimleInt(3));
  ASimpled b(2);
  b.list_of_B_.push_back(SimleInt(10));
  b.list_of_B_.push_back(SimleInt(20));
  b.list_of_B_.push_back(SimleInt(30));
  prime.map_of_A_.insert(make_pair(a.id_, a));
  prime.map_of_A_.insert(make_pair(b.id_, b));

  prime.printParticularA(2);

return 0;
}

Answer 3

虽然您没有包含List 的实现，但问题可能就在那里。更准确地说，List 的 begin() 和 end() 成员函数可能会被破坏。它们返回的值可能是相同的（或无效的），导致基于范围的 for 循环什么都不做。这当然是基于您的 set::find 返回一个有效的迭代器而不是 end 迭代器。

以下示例是对您问题中代码的修改。它使用std::list 而不是List 并且不使用AFinder，因为您还没有包含它的代码。

#include <set>
#include <list>
#include <iostream>

struct B
{
    int id_;
    explicit B(int id) : id_(id) {}
    void print() const
    {
        std::cout << "B::id = " << id_ << std::endl;
    }
};

class A : public std::list<B>
{
public:
    explicit A(int id) : id_(id) {}

    bool operator<(const A& rhs) const
    {
        return id_ < rhs.id_;
    }

    bool operator==(const A& other) const
    {
        return id_ == other.id_;
    }

    void printReport() const
    {  
        for(auto& item : *this)
        {
            item.print();
        }
    }

private:  

    // data members.  
    int id_;

};


class Prime : public std::set<A>
{
public:

    void printParticularA(const int& id)
    {
        std::cout << "finding " << id << std::endl;
        auto el = find(A(id));
        if(el == cend())
        {
            std::cout << "not found" << std::endl;
        }
        else
        {
            find(A(id))->printReport();
        }
        std::cout << "done finding " << id << std::endl;
    }
};


int main()
{
    Prime p;

    A   a1(1);
    a1.push_back(B(1));
    a1.push_back(B(2));
    a1.push_back(B(3));
    p.insert(a1);

    A   a2(2);
    a2.push_back(B(4));
    a2.push_back(B(5));
    a2.push_back(B(6));
    p.insert(a2);

    p.printParticularA(1);

    p.printParticularA(2);

    // doesn't exit
    p.printParticularA(3);
}

这会产生以下输出。

找到 1
B::id = 1
B::id = 2
B::id = 3
完成查找 1
发现 2
B::id = 4
B::id = 5
B::id = 6
完成查找 2
发现 3
没找到
找到了 3