Question

I have a problem which seems simple, but I can’t find an elegant solution for it.

I’m using a linked list which I need to sort twice:

• once on one parameter as list elements are added, and
• once on a different parameter after some processing.

The objects I store in the list inherit from an abstract list item base class.

The problem is with resorting on the second parameter. I don’t want to write a pure virtual accessor for it in the list item base class, because I later store some other objects in the list which also inherit from the list item base class, but the second accessor wouldn’t make sense for them.

Is there a clean solution that I’m missing?

Answer 1

If I understand correctly, you’ve something like that :

 class Base {
    public:
    int getParam1() const { ... }; 
    virtual void foo() =0;  // this is an abstract class
    virtual ~Base() { ... }
 }
 class Derived : public Base {
    public:
    int getParam1() const { ... }
    int getParam2() const { ... }

 }

And you have a std::list<Base*> myList somewhere. The first time you want to sort your list, you do something like :

sort(list.begin(),list.end(),[](const Base*v1,const Base*v2) {
    return v1->getParam1()<v2->getParam1();
});

And for the second sort, you need to use something specific to the class Derived. You don’t want to add a pure virtual accessor getParam2() into Base & implement it in Derived. But if you know that your list contains only Derived objets, you can use a cast without problem :

sort(list.begin(),list.end(),[](const Base*b1,const Base*b2) {
    const Derived * d1 = dynamic_cast<const Derived*>(b1);
    const Derived * d2 = dynamic_cast<const Derived*>(b2);

    return d1->getParam2() < d2->getParam2();
});

Note that if an object of your list is not a Derived, dynamic_cast will return nullptr so you can safely check it.