1.	Adding of a new virtual method to a class exported 
from a DLL can cause the following problems: 
o	If class already has a virtual method B and we are 
adding a new one named A before it, then we are changing 
the table of virtual methods. Now the first virtual method 
in the table will be A but not B and the client program 
which calls B will fail without recompilation as the call 
of B will cause the call of A and this is another method 
which possibly has other parameters and return type. 
o	When a class doesn?t have virtual methods and none 
of its base classes have, then adding of a new virtual 
method to it or to its base class will cause adding of the 
pointer for the table of virtual methods. This will cause 
change in the class size. So the error will occur after a 
client program will allocate memory for the class (an 
amount of memory that was required before the class has 
been changed) and will try to modify some of the class' 
fields explicitly or implicitly. In this case, as the 
pointer to the table of virtual method is added to the 
beginning of the class, all addresses of the class fields 
are shifted and thus we will get an abnormal client program 
behavior or a runtime error. 
o	In case when a class has virtual methods or any of 
its parent classes has, we can?t add virtual methods to 
classes exported from the DLL if they participate in the 
inheritance. We can?t add virtual methods not only to the 
beginning of the class declaration but also to the end of 
it. The problem is in shifting in the table of virtual 
methods. Note that even if you add a new virtual method to 
the end of the class declaration then the child?s virtual 
methods will be shifted. 
2.	Adding of a new field (of any kind) to a class 
declaration can cause following problems: 
1.	Adding of a new field to the end of a class causes 
class size to change as in the case of adding of a virtual 
method to a class that didn?t have any. The client program 
will allocate less memory than it is required for a new 
class and this will cause referencing to the memory out of 
the class scope. 
2.	Adding of a new field between existing ones is even 
worse. It will case all addresses of fields after the new 
one to be shifted and a client application will work with 
the incorrect addresses while working with the fields that 
are situated after the new field. We also have the problem 
as in the previous point here.

Overwriting a older version of dll by a new version of dll 
is known as Dll Hell problem.