static-libraries

I have a bunch of static libraries (*.a), and I want to build a shared library (*.so) to link against those static libraries (*.a). How can I do so in gcc/g++? You can (just extract all the .o files and link them with -shared to make a .so ), but whether it works, and how well it works, depends on the platform and whether the static library was compiled as position-independent code (PIC). On some platforms (e.g. x86_64), non-PIC code is not valid in shared libraries and will not work (actually I think the linker will refuse to make the .so ). On other platforms, non-PIC code will work in

I have a bunch of projects that all could share a "common" static library of classes. What confuses me is if I make a static library out of these classes and link against it in my projects that I still need the headers of the classes in the static library in my main projects. What is the benefit of the static library then? How do companies like Adobe deal with this? Static libraries allow you to create a library and use that library in many projects. The need for header files: Since the project using the library is programmed and compiled independent of the library, that program needs to know

g++ (Ubuntu/Linaro 4.4.4-14ubuntu5) 4.4.5 I have the following static library called sdpAPI.a. I am having problems trying to link it with my test application. Just wondering if I am doing something wrong. The static library has been built with g++; My directory is as follows: /projects/unit_test/main.c /projects/unit_test/sdp/inc/sdpAPH.h /projects/unit_test/sdp/lib/sdpAPI.a My source code is this: #include <stdio.h> #include "sdpAPI.h" int main(void) { printf("----- TEST SDP ------\n"); try { sdpSessionDescription sdp; sdp.clear(); } catch(...) { printf("----- TEST FAILED --------\n");

I know .OBJ is the result of compiling a unit of compilation and .LIB is a static library that can be created from several .OBJ, but this difference seems to be only in the number of units of compilation. Is there any other difference? Is it the same or different file format? I have come to this question when wondering if the same static variable defined in two (or more) .LIBs is merged or not during linking into the final executable. For .OBJs the variables are merged. But is it the same in .LIBs? A .LIB file is a collection of .OBJ files concatenated together with an index. There should be

I have shared object A.so which statically links to libssl.a & another shared object B.so which also statically links libssl.a . A.so & B.so has symbols from libssl.a in GLOBAL scope. I checked this by readelf -s A.so I have an executable a.out which loads A.so and B.so. When a.out terminated I get a double free error in one of the symbols from libssl.a in A.so. Even though libssl.a is statically linked to each shared object, since they are exposed globally is it possible that the same symbol is shared instead of picking it's local copy. What is the workaround this ? How to make the symbols

Suppose that I've got the following libraries: add_library(myLib_static STATIC ${SRC_FILES}) add_library(myLib SHARED ${SRC_FILES}) # installing header files install(FILES ${H_FILES} DESTINATION ${INSTDIRHEADER}) # installing binaries install(TARGETS myLib_static DESTINATION ${INSTDIRBIN}) install(TARGETS myLib DESTINATION ${INSTDIRBIN}) If I execute the following command, both shared and static libraries will be installed: make install How can I have separate install commands for each of them? Something like this: make install-static make install-shared Update : Header files should also be

I want to hide symbol names which are not relevant to the last user and make visible only APIs in my shared or static library. I have a simple code like that: int f_b1(){ return 21 ; } int f_b3(){ return f_b1() ; } I applied the all methods stated here such as using __attribute__ ((visibility ("hidden"))) and static data but got no successful result. My operating system is Ubuntu and x86_64 GNU/Linux processor. Do we use special options while compiling with gcc? I am listing modules and function of libraries with nm command. In my example above I only want to make visible f_b3 function. When I

I have created a system that automatically registers function objects (functors) into a map based on the constructor of an global instance. In each cpp file that defines the functor, there's a global instance of the registrar class instance to register the functor to a singleton std::map<int, std::function<...> > object. This is the definition of registrar class: template < typename map_type, typename handler_type > struct registrar { registrar ( map_type& map_object, boost::uint16_t cmd_code, const handler_type& handler ) { map_object.insert(std::pair<boost::uint16_t, handler_type>(cmd_code,