Question

Suppose my class is depending on other library. Now I need to modify the class for one application. What kind of modification will force me to recompile
all libraries. What’s the rule to recompile all libraries?

for example, I only know the case 2) is like this. What about the others?

1) add a constructor

2) add a data member

3) change destructor into virtual

4) add an argument with default value to an existing member function

Answer 1

Do you really mean that the class you are changing depends on the library? You never have to recompile a library because you’ve changed something that depends on the library. You recompile a library if you change something that the library depends on.

The answer is that in C++, technically all of those things require recompiling anything that uses the class. The one definition rule only permits classes to be defined in multiple translation units if the definitions are exactly the same in all units (I think “exactly” means the same sequence of tokens after preprocessing, in which case even changing the name of a parameter requires recompilation). So if different source files share a header, and a class definition in that header changes, C++ guarantees nothing about whether code compiled from those two source files remains compatible if only one of them is rebuilt.

However, your particular C++ implementation will use a static/dynamic library format which relaxes the rules, and allows some changes to be “binary compatible”. Of the things you list, only (1) has much chance of being binary compatible. You’d have to check your documentation, but it’s probably fine. In general (2) changes the size and layout of the objects, (3) changes the code required by the caller to destroy objects, and (4) changes the signature of the function (default values are inserted by the calling code, not the callee).

It’s often worth avoiding default parameters pretty much for this reason. Just add another overload. So instead of changing:

void foo(int a);

to

void foo(int a, int b = 0);

replace it with:

void foo(int a) { foo(a, 0); }
void foo(int a, int b);

Of course the former change isn’t even source-compatible if a user is taking a pointer to the function foo, let alone binary compatible. The latter is source-compatible provided that the ambiguity is resolved over which foo to use. C++ does make some effort to help with this, initializing a function pointer is a rare (only?) case where context affects the value of an expression.