STL List - 作为指针对象的数据类型

Question

我在使用继承和 STL 列表库时遇到问题...

比如说，我有一个带有两个派生类的抽象基类（其中定义了所有比较运算符）。该列表是在

list<StoreItem*> items;

我插入一个名为 Food 或 Clothing 的派生类（抽象基类 StoreItem）时声明的。我创建了一个即将插入的新 StoreItem 指针：

StoreItem* item = new Food(arguments here);

现在，我想将这个新项目（按顺序）插入到列表中，我的尝试是这样的：

list<StoreItem*>::iterator iter;
for (iter = inventory.begin(); iter != inventory.end(); iter++)
{
    if (*item < **iter)
        break; // break out to insert
}

inventory.insert(iter, item);

我做错了什么吗？另外，我如何从库存中提取信息？ （例如：使用复制构造函数的 Food tempFruit(**iter)）。

先感谢您！祝你有美好的一天。

Answer 1

您假设从列表中提取的项目是一个 Food 实例；然而，编译器不知道这一点。当您从列表中的项目（表观类型为 StoreItem 的项目）构造 Food 的新实例时，您正在尝试调用 Food::Food( const StoreItem) 或兼容的东西。为什么？因为迭代器指向 StoreItem*，它可能是 StoreItem 对象的实例，或者是从 派生的任何类的实例StoreItem，例如Food。

正如其他发帖者所评论的那样，多态性是成功的关键。您真的需要知道该物品是食物吗？如果没有，则访问所有商店商品共享的界面（例如价格、序列号等）。如果您需要了解该项目的具体信息，那么您可以尝试推断其类型：

Food *food = dynamic_cast<Food*>(*iter);
if (food != NULL) {
   // perform food related logic
   std::cout << "Ingredients: " << food->ingredients() << std::endl;
}
else {
   std::cout << "I can't eat that!" << std::endl;
}

Answer 2

如果您已经定义了 StoreItem::operator<，这将会起作用，但还有另一种方法可能会更好一些。 STL 已经冷排序了。您可以为 StoreItem* 定义 <，然后使用 list<...>::sort()。

（您可能已经考虑过定义自己的 SortedItemList 类来处理内部排序。）

是的，tempMovie(**iter) 可以工作，除其他方式外。

编辑：

我认为我谈论从库存中取出一些东西为时过早。这是有效的：

list<StoreItem *>::iterator citr = items.begin();

Food *fp = dynamic_cast<Food *>(*citr);

Food ff(*fp);

请注意，您必须知道此 StoreItem* 实际上指向 Food - 如果它指向 Clothing，您将出现分段错误或更糟的情况。要找到答案，您可以实现自己的 StoreItem::whatTypeAmI()，或者使用 C++ 的运行时类型识别：（

#include <typeinfo>
...
Food a;
StoreItem *sp = *citr;
if(typeid(*sp)==typeid(a))
{
  // it's a Food
}

请注意，您可以使用 StoreItem* 做很多事情code> 或 StoreItem& 而不知道它的类型——多态性是你的朋友。）

Answer 3

如果您可以在指向基类的两个指针之间定义比较运算符，则无需编写任何其他代码即可获得有序集合。根据您的应用程序，您可能需要一个集合或堆，甚至可能是一个映射。这是执行此操作的习惯用法...（基数是从字符串公开派生的）。

template<>
struct std::less<base*>
{
   bool operator()(const base* lhs, const base* rhs) const
   {
      return *lhs < *rhs;
   }
};

typedef set<base*> S;

int _tmain(int argc, _TCHAR* argv[])
{
    base able(std::string("able"));
    base baker(std::string("baker"));
    base charlie(std::string("charlie"));

    S inventory;
    inventory.insert(&charlie);
    inventory.insert(&able);
    inventory.insert(&baker);

    for (S::iterator i = inventory.begin(); i != inventory.end(); ++i)
        std::cout << **i << endl;
    return 0;
}

输出：
能够
面包师
charlie

在发现这个习语之前，你可能会闲逛一段时间。发生的事情是您正在专门使用库模板 std::less for T=base*;然后，它就像魔法一样插入到 std::set （或其他有序容器）的默认比较器参数中。

Answer 4

您可以使用 boost 来代替自制任何解决方案::ptr_list。如果您打算将指针存储在像容器这样的 STL 中，那么事情会变得容易得多。然后您所需要做的就是为您尝试插入的任何项目定义 operator< 。请记住，ptr_list 不适合与共享所有权一起使用。要实现此目的，请在 std::list 中使用 std::shared_ptrS 并为您的 shared_ptr 专门化 std::less > 类型。

Answer 5

通过为 StoreItem 指针定义的比较函数，您可以缩短插入代码，如下所示：

bool less_ptr( const StoreItem*& lhs, const StoreItem*& rhs )
{
    return *lhs < *rhs;
}

Insertion:

StoreItem* item = new Food(arguments here);
inventory.insert( std::upper_bound( inventory.begin(), inventory.end(), item, less_ptr ), item);

std::upper_bound (#include) 假设您的列表已排序，因此如果您始终保持列表排序，则这适用。

至于将数据拉出来，需要考虑两件事：

1. 如果使用复制构造函数重新创建对象，则您正在创建新对象，并且更改它们不会更改列表中的对象，因此最好使用指针
2. 您必须根据存储的对象的类型分割代码路径

您可以这样做：

Food* foodObj = NULL;
Clothing* clothesObj = NULL;

list<StoreItem *>::iterator it = inventory.find( /* something */ );
StoreItem* item = *it;

item->DoSomethingWithAnyStoreItem(); // It's best to only use such methods

// But if you need something only a derived class has...
foodObj = dynamic_cast<Food*>(item);
clothesObj = dynamic_cast<Clothes*>(item);

if( foodObj != NULL )
{
    foodObj->DoSomethingWithFood();
    Food newFood( *foodObj );
    newFood.DoSomethingWithCopyOfFood();
}
else if( clothesObj != NULL )
{
    clothesObj->DoSomethingWithClothes();
}
else
{
    // It's neither Food, nor Clothes
}