Re: Linking libraries
On Jul 2, 6:55 pm, Giuliano Bertoletti <gbe32...@libero.it> wrote:
I'm planning to write a large application (in C++) which would
used of some third party C++ libraries (for which I've source
code).
I've always wondered which is the best way to design such a
thing up in a clever way: I mean, shall I compile each
translation unit and then link everything together at the end
or shall I assemble the units into distinct libraries and then
link them with my app.
I'd certainly "link" each of the third party applications into a
separate library, and maintain them separately from the rest of
the application. For you're own code, it depends somewhat on
the complexity, but it's often useful to break it up into
several libraries as well.
My concern is that, regardless of the OS, each library if
compiled as a separate unit would have its own libc and other
shared libraries.
Why?
Generally, I'd recommend using static linking for all but the
system libraries, if for no other reason than to facilitate
deployment. You should almost certainly use dynamic linking for
the system libraries, however. On systems where the system
libraries are not clearly separated from the C runtime (Unix,
Windows), this means that the C runtime will be dynamically
linked as well. (Under Unix, libc.so is bundled with the OS, so
you don't have to worry about it when deploying. Windows is a
bit more awkward, but in practice, you generally only have to
install one or two additional DLL's, and the Microsoft
documentation explains in a detailed manner how to do this---and
why you can't do it with a "debug" release:-).)
This might be a problem because I'll have to take care, for
example, of creating and destroying objects with the same
instance of libc (or whaterver is resolving new and delete
operator)
This is never a problem under Unix, because libc is always
shared. Under Windows, it's only a problem if you use DLL's
yourself, and link them with a version of the runtime which is
statically linked.
On the other hand if I consider the project as a collection of
translation units and link them together at the end, it would
be hard to maintain and probably have to rewrite makefiles for
libraries.
What's your advice ?
Unless there are important reasons not to, link everything
statically (except the system library). That doesn't mean not
using libraries, however, for modularization.
--
James Kanze