Сравнение производных классов

enum enm {
    S_ENM = 0,
    A_ENM = 1,
};
 
class S {
    const enm ID_;
 
public:
    explicit S() : ID_(S_ENM) {
    }
 
    explicit S(const enm ID) : ID_(ID) {
    }
 
    //  компаратор по ID_
};
 
class A : public S {
public:
    explicit A() : S(A_ENM) {
    }
};

#include <iostream>
#include <typeinfo>
#include <memory>
 
class B {
public:
   virtual void foo() {}
};
 
class Ch1 : public B {};
class Ch2 : public B {};
class Ch3 : public Ch1 {};
 
using namespace std;
int main() {
   shared_ptr<B> ptr1(new B);
   shared_ptr<B> ptr2(new Ch1);
   shared_ptr<B> ptr3(new Ch2);
   shared_ptr<B> ptr4(new Ch3);
   
   cout << typeid( *ptr1 ).name() << endl;   
   cout << typeid( *ptr2 ).name() << endl;   
   cout << typeid( *ptr3 ).name() << endl;   
   cout << typeid( *ptr4 ).name() << endl;   
   cout<< typeid( *ptr4 ).before(typeid( *ptr1))<<endl;
   cout<< typeid( *ptr2 ).before(typeid( *ptr4))<<endl;   
}

class S {
public:
  virtual int priority() const {
    return 1;
  }
 
  struct comparer {
    bool operator()( const S* s1, const S* s2 ) const {
      return s1->priority() < s2->priority();
    }
  };
};
 
class B : public S {
public:
  virtual int priority() const {
    return 2;
  }
};
 
class C : public S {
public:
  virtual int priority() const {
    return 3;
  }
};
 
int main() {
  std::set<S*, S::comparer> objs;
  objs.insert( new B );
 
  return 0;
}

#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
class BasePriority {
public:
    virtual int GetPriority() const = 0;
    virtual std::string Name() const = 0;
};
 
template <int p>
class Priority : public BasePriority {
public:
    int GetPriority() const override { return priority_; }
private:
    static const int priority_ = p;
};
 
class A : public Priority<2> {
public:
    std::string Name() const override {
        return "class A";
    }
};
 
class B : public Priority<1> {
public:
    std::string Name() const override {
        return "class B";
    }
};
 
typedef std::shared_ptr<BasePriority> BasePriorityPtr;
typedef std::vector<BasePriorityPtr> BasePtrContainer;
 
int main() {
    struct PriorityComparator {
        bool operator()(const BasePriorityPtr& lhs,
                const BasePriorityPtr& rhs) const {
            return lhs->GetPriority() < rhs->GetPriority();
        }
    };
        
    BasePtrContainer container {
        std::make_shared<B>(),
        std::make_shared<A>(),
        std::make_shared<B>(),
        std::make_shared<B>()
    };
    
    std::sort(container.begin(), container.end(), PriorityComparator());
    
    for (const auto& item : container) {
        std::cout << item->Name() << std::endl;
    }
    
    return 0;
}

std::string Name() const override { return "class A"; }