Quote:Original post by Numsgil

Quote:Original post by the_edd
Limiting the use of dynamic_cast is the way it should be, you shouldn't be seeking to change that. An abundance of dynamic_casts (or any type of cast, really) points to design problems.

That depends. Should we avoid dynamic casts because they're slow,

Quote:or because they lead to bad designs?

Quote: A program in another language using dynamic typing is certainly valid if that's how the language is meant to be used.

Quote:Ruby for example. I haven't done much dynamic typing myself, but I recognize lots of strengths from it.

Quote:I would say you should avoid dynamic casts because they're slow, not because there's something inherently less flexible, or more risky, about a design incorporating them. Well, that and C++ is really built to be statically typed, and you're kind of twisting it to be dynamically typed. So you might code yourself in to a dead end with language limitations. But at its core I don't think there's anything evil about dynamic casting. Or I haven't seen any evidence of it anyway.

Quote:Original post by the_edd
For example in Python when I call a lambda or a function or an instance of a class that has a __call__ method, the interpreter doesn't dynamic_cast the object I'm calling to a function. It simply asks the object if it's callable.

ISomeInterface *pointer = dynamic_cast<ISomeInterface *>(MyObject);if(pointer)    pointer->SomeFunction();else    //some error, or ignore

Quote:Original post by Numsgil:

void SerializeToNetwork(Object *Ob){    INetworkable *network = dynamic_cast<INetworkable *>(Ob);    if(network)        network->SendNetworkData();}

void SerializeToNetwork(Object *Ob){    INetworkable *network = Ob->GetInterface<INetworkable>();    if(network)        network->SendNetworkData();}

template<class T>T* Object::GetInterface(){	InterfaceMap::iterator itInterface = m_Interfaces.find( GetTypeInfo<T>() );	if( itInterface != m_Interfaces.end() )	{		return static_cast<T*>( itInterface->second );	}	return NULL;}

	#if the compiler has fast RTTI		class TypeInfo		{		public:			TypeInfo() : t(0) {}			TypeInfo( const std::type_info& t ) : t(&t) {}			TypeInfo( const TypeInfo& t ) : t(t.t) {}			bool operator==(const TypeInfo& rhs) const { return t == rhs.t || (t && rhs.t && *t == *rhs.t); }			bool operator!=(const TypeInfo& rhs) const { return !(*this == rhs); }		private:			const std::type_info* t;		};		template<class T>		inline TypeInfo GetTypeInfo() { return typeid( T ); }	#else		typedef uint32 TypeInfo;		template<class T>		inline TypeInfo GetTypeInfo(  ) { static uint32 hashT = hash::Fnv32a(typeid(T).name()); return hashT; }	#endif

Quote:Original post by Hodgman

Quote:Original post by Numsgil:

void SerializeToNetwork(Object *Ob){    INetworkable *network = dynamic_cast<INetworkable *>(Ob);    if(network)        network->SendNetworkData();}

In my engine, I would write it like this:*** Source Snippet Removed ***
GetInterface looks like this:*** Source Snippet Removed ***
N.B. m_Interfaces is a std::map<TypeInfo,void*>
In the objects constructor, it populates m_Interfaces by doing static_casts to each interface type that it supports.
e.g. m_Interfaces[GetTypeInfo<INetworkable>()] = static_cast<INetworkable*>( this );

TypeInfo and GetTypeInfo are my wrapper for C++'s native RTTI. On compilers that have fast RTTI I just let the compiler do it, but on MSVC I try and optimize type comparisons:*** Source Snippet Removed ***
This does run the risk of hash-collisions though, so the next thing I'm going to do with this code is check for collisions in debug builds...

Also this system bloats the size of your objects because the interface map is stored per-object, not per-class (but you can use that to have objects choose whether they expose an interface or not at runtime, if needed).

Quote:Original post by Numsgil
It's just a pain because it's so brittle to overworked programmers forgetting to add an interface. Every new class has to do something in it's ctor, and it's easy to forget. Every new interface you add needs to add something to the ctor and that's easy to forget, too. And heaven forbid if you remove and interface and forget to modify the ctor.

Quote:Original post by Hodgman
In my engine, I would write it like this

void SerializeToNetwork(Object *Ob){    INetworkable *network = Ob->GetInterface<INetworkable>();    if(network)        network->SendNetworkData();}

void SerializeToNetwork(IUnknown *Ob){    CComQIPtr<INetworkable> network = Ob;    if (network)        network->SendNetworkData();}