• You're using literally anything but gcc / clang. See: MSVC, SunCC, Intel C compiler, CodeWarriors, the BREW SDK (one of the worst things I've used), countless "C+" compilers for random Japanese embedded systems that don't work, the Borland tooling, HP aC++, why are there so many compilers??? And how the hell did IBM write five of them during its lifetime?
  
• Sometimes when you're using clang. Because it's still in beta.
  
• That time that you passed -O3 and gcc completely farted itself.
  
• You're compiling for something that isn't x86-64. Like ARM, ARC, PPC, SPARC, or even i386.
  

• you're cross-compiling
  
• the compiler is more than 3 years old
  

hackbunny fucked around with this message at 01:09 on Jan 16, 2015

class DongBase;

class BaseFactory {
  std::map<std::string, BaseFactory*> factories;
protected:
  static void register_factory(std::string n, BaseFactory *f) { factories.push_back(std::make_pair(n, f)); }
  virtual DongBase * internal_create() const = 0;
public:
  DongBase * create(std::string name) const {
    auto f = factories.find(name);
    if (f != factories.end()) return f->internal_create();
    else return nullptr;
  }
};
template<class T>
class DongFactory : BaseFactory {
protected:
  DongBase * internal_create() const override { return new T(); }
public:
  DongFactory(std::string name) { register_factory(name, this); }
};

nielsm fucked around with this message at 11:57 on Jan 17, 2015

struct registry {
    struct entry {
        const char *name;
        bool (*is_instance)(const Object*);
    };
    
    template<typename T>
    void push(const char *name) {
        T t;
        auto it = std::find_if(begin(v), end(v), [&t](const entry& e) { return e.is_instance(std::addressof(t)); });
        v.emplace(it, entry{
            name,
            [](const Object *o) { return dynamic_cast<const T*>(o) != nullptr; }
        });
    }
    
    const entry *find(Object *o) {
        auto it = std::find_if(begin(v), end(v), [o](const entry& e) { return e.is_instance(o); });
        return it == end(v) ? nullptr : std::addressof(*it);
    }
    
    std::vector<entry> v;
};

struct registry {
    struct entry {
        const char *name;
        bool (*is_instance)(const Object*);
        void (*throws)();
        bool (*can_catch_when)(void(*)());
    };
    
    static bool is_base_of(const entry& base, const entry& derived) {
        return base.can_catch_when(derived.throws);
    }
    
    template<typename T>
    void push(const char *name) {
        entry e = {
            name,
            [](const Object *o) { return dynamic_cast<const T*>(o) != nullptr; },
            [] { throw static_cast<T*>(nullptr); },
            [](void (*throws)()) { try { throws(); } catch (T*) { return true; } catch (...) {} return false; }
        };
        auto it = std::find_if(begin(v), end(v), [&e](const entry& base) { return is_base_of(base, e); });
        v.emplace(it, std::move(e));
    }
    
    // ...
};

The Laplace Demon fucked around with this message at 08:59 on Jan 20, 2015

Schmerm fucked around with this message at 19:28 on Jan 20, 2015

roomforthetuna fucked around with this message at 07:36 on Jan 27, 2015