How to mix C++ and C correctly

Question

I am having some problems with this: I need to write a C wrapper for a C++ library. Say I have 3 files:

wrapper.h

typedef struct Foo Foo;
Foo* create_foo();

wrapper.cpp

extern "C" {
    #include "wrapper.h"
}
#include "foo.h"

Foo* create_foo() {
    return new Foo;
}

foo.h
```
class Foo {
public:
    Foo();
};
```

This compiles fine:

clang++ -std=c++14 wrapper.cpp foo.h wrapper.h -shared -fPIC

clang++ -shared -o libbindings.so a.out

but when compiling the program that uses the C wrapper (it is compiler and linked by the programming language that uses the wrapper - Crystal), I get an undefined reference to create_foo() and a linker error collect2: error: ld returned 1 exit status. How can I debug this (and what am I doing wrong)?

You told the linker to link against `libshared_library_providing_create_foo.so` by specifying the option `-lshared_library_providing_create_foo`? — alk, Aug 09 '15 at 10:05
Show your `wrapper.h` (assuming that's what the C program includes). — melpomene, Aug 09 '15 at 10:11
@melpomene It's exactly as I've described it, only a typedef and function declaration — Zihemu, Aug 09 '15 at 10:21
Adding a lib to `LD_LIBRARY_PATH` helps to find the lib on run-time. You also need it on link-time. `LD_LIBRARY_PATH` is not evaluated by the linker then. You want to show us how you compile/link the program. — alk, Aug 09 '15 at 10:28
You might like to read around here: http://stackoverflow.com/q/12573816/694576 — alk, Aug 09 '15 at 10:30
@alk The wrapper? `clang++ 'pkg-config --libs --cflags dependent-lib' -std=c++14 wrapper.cpp foo.h wrapper.h -shared -fPIC` (I replaced the backticks) The program that uses the wrapper is compiled and linked by the programming language, the error is @ cc. — Zihemu, Aug 09 '15 at 10:35
You don't seem to provide the entire error? What's the output before this “collect2: error: ld returned 1 exit status” line? — fuz, Aug 09 '15 at 10:35
No, the compilation command which leads to the undefined reference error ... — alk, Aug 09 '15 at 10:38
I mean that (1) header files do not belong on the compilation line, so `clang++ -std=c++14 wrapper.cpp foo.h wrapper.h -shared -fPIC` should be just `clang++ -std=c++14 wrapper.cpp -shared -fPIC` and (2) you declare a default constructor for class Foo but never define it. — n. m. could be an AI, Aug 09 '15 at 11:08
Constructors are implicitly defined only when you don't declare them. — n. m. could be an AI, Aug 09 '15 at 11:17
@DavidHaim Err....? C is, for better or worse, the established "lingua franca" for low-level code interfaces. What's your proposed alternative? — Kyle Strand, Oct 03 '16 at 23:32

Galik · Accepted Answer · 2016-12-28T07:07:29.023

Here is a working example:

wrapper.h (C & C++ aware)

#ifndef WRAPPER_H_
#define WRAPPER_H_

#ifdef __cplusplus
extern "C" {
#endif

typedef struct CPPClass CPPClass;

CPPClass* CPPClass_new();
void CPPClass_do_something(CPPClass* cppclass);
int CPPClass_get_state(CPPClass* cppclass);
void CPPClass_delete(CPPClass* cppclass);

#ifdef __cplusplus
}
#endif
#endif /* WRAPPER_H_ */

wrapper.cpp (C++ only)

#include "wrapper.h"

class CPPClass
{
    int state;
public:
    CPPClass(): state(0) {}
    void do_something() { ++state; }
    int get_state() const { return state; }
};

extern "C" CPPClass* CPPClass_new()
{
    return new CPPClass;
}

extern "C" void CPPClass_do_something(CPPClass* cppclass)
{
    cppclass->do_something();
}

extern "C" int CPPClass_get_state(CPPClass* cppclass)
{
    return cppclass->get_state();
}

extern "C" void CPPClass_delete(CPPClass* cppclass)
{
    delete cppclass;
}

use-wrapper.c (C only)

#include <stdio.h>
#include "wrapper.h"

int main(void)
{
    CPPClass* cppclass = CPPClass_new();

    if(!cppclass)
    {
        printf("ERROR: failed to create CPPClass:\n");
        return 1;
    }

    printf("state: %d\n", CPPClass_get_state(cppclass));
    CPPClass_do_something(cppclass);
    printf("state: %d\n", CPPClass_get_state(cppclass));

    CPPClass_delete(cppclass);
}

Compile CPP

g++ -std=c++11 -shared -fPIC -o libwrapper.so wrapper.cpp

Compile C

gcc -o use-wrapper use-wrapper.c -L. -lwrapper -lstdc++

Output:

$ ./use-wrapper 
state: 0
state: 1

Hope that helps.

n. m. could be an AI · Answer 2 · 2015-08-09T11:56:50.990

You are creating a shared object named a.out, then another shared object named libbindings.so that ostensibly links to a.out but references nothing from it. Now if a set of input files doesn't have any undefined symbols, no libraries are searched or added to the output. So libbindings.so is essentially an empty library. Verify:

 % nm a.out | grep create_foo
 00000000000006bc T create_foo
 % nm libbindings.so | grep create_foo
 %

If you have several source files, you should build an object file from each source (use -c compilation flag), (then optionally combine the objects into a static library --- skip this step if you are not releasing static libraries) then build a shared object from previously built objects:

  clang++ -c -fPIC foo.cpp
  clang++ -c -fPIC bar.cpp
  clang++ -shared -o libfoobar.so foo.o bar.o

If you only have one source, or very few source files you can easily compile together, you can build the shared library in one step:

  clang++ -std=c++14 wrapper.cpp somethingelse.cpp -shared -fPIC -o libbindings.so

This is not recommended for large projects.

Thanks! But the other answer was more complete and might help more people, even though I understand that the whole problem was in how I built the library. Thanks, again :) — Zihemu, Aug 09 '15 at 11:54

How to mix C++ and C correctly

2 Answers2

Linked

Related