Is it possible to include C++ libraries in C programs?

Yes, it is possible. However, as BoBTFish says in a comment above, you (or the contractor) must design a C interface for the C++ library:

• write a header file that compiles in both C and C++, and that declares some extern "C" functions. The interfaces of these functions must be valid in C, which in C++ terms means they use only POD types (for example no references) and don't throw exceptions. You can declare non-POD C++ classes as incomplete types and use pointers to them, so commonly each non-static member function is wrapped by a function that takes the pointer that will become this as its first parameter.
• implement the functions in C++ to call the C++ library
• compile the library and the wrapper as C++
• compile your program as C (you can #include the header wherever needed)
• link it all together with g++ so that the C++ components can link against libstdc++.

I suppose you might argue that since the program is linked with g++, it's by definition a C++ program that uses a C library (that happens to contain main) rather than a C program that uses a C++ library. Personally I wouldn't bother arguing that, the important point is that none of your existing C code changes.

Example:

lib.h

#ifdef __cplusplus extern "C" #endif int foo(); 

lib.cpp

#include "lib.h" #include <vector> #include <iostream> int foo() { try { std::vector<int> v; v.push_back(1); v.push_back(1); std::cout << "C++ seems to exist\n"; return v.size(); } catch (...) { return -1; } } 

main.c

#include "lib.h" #include <stdio.h> int main() { printf("%d\n", foo()); } 

build

g++ lib.cpp -c -olib.o gcc main.c -c -omain.o g++ main.o lib.o -omain 

The following also works instead of the third line, if you do want to make an arbitrary distinction between using gcc to link and using g++:

gcc main.o lib.o -llibstdc++ -omain 

However, I am not certain that gcc -libstdc++ will work as well as g++ for all possible code that could be in lib.cpp. I just tested it for this example, and of course there's a lot of C++ that I haven't used.

This little dynamic library (g++) and program (gcc) compiles and links perfectly:

Header library.h

#ifdef __cplusplus extern "C" { #endif typedef struct TagPerson {} Person; extern Person* person_create(const char* name); extern void person_destroy(Person* p); extern const char* person_name(Person* p); extern Person* person_exception(Person* p); #ifdef __cplusplus } #endif 

C++ Source library.cc compiled with g++ -shared -fpic library.cc -o libLibrary.so

#include <iostream> #include <string> #include <stdexcept> #include "library.h" namespace Library { class Person { public: Person(const std::string& name) : m_name(name) { std::cout << m_name << std::endl; } const std::string name() const { return m_name; } void exception() { throw std::runtime_error(""); } private: std::string m_name; }; } // namespace N extern "C" { #define PERSON(P) ((Library::Person*)(P)) extern Person* person_create(const char* name) { try { return (Person*)(new Library::Person(name)); } catch(...) { // Error Procession; } return 0; } extern void person_destroy(Person* p) { delete PERSON(p); } extern const char* person_name(Person* p) { return PERSON(p)->name().c_str(); } extern Person* person_exception(Person* p) { try { PERSON(p)->exception(); } catch(...) { std::cerr << "Exception" << std::endl; } return 0; } } // extern "C" 

C Source main.c compiled with gcc main.c -lLibrary -o Test

#include <stdio.h> #include "library.h" int main() { Person* p = person_create("Jaco Pastorius"); printf("%s\n", person_name(p)); person_exception(p); person_destroy(p); return 0; } 

What exactly is the issue? Do you already have a delivered library in the "wrong" language or is it that your contractor wants to develop the library in C++ but you need it to link from C?

In the former case, assuming you specified things correctly you should make it your contractor's problem but if you didn't or if that's not possible you'll need to write an interface as Steve Jessop suggests above.

In the latter case, it's really not an issue: the contractor will need to ensure that she provides the code in a form that is callable from C and safe/secure/stable to call in that manner. The internal code that does the work can really be anything at all providing she wraps it up for you in the correct manner. If you're planning on building the library yourself, you will need them to provide suitable build scripts that invoke the compiler in the right manner. I guess there's a potential maintenance issue if your in-house programmers can't cope with C++ but that's an issue to do with recruitment/employment not the technical details of how it works.