How to create C API to C++ Function - c++

Question

I am learning how to generate an array of random numbers in C++. I am using a std::vector and std::generate (I'm trying to use modern idiomatic C++ - not sure how well I'm doing).
What I would like to do is to expose this function to plain old C code. How can make this function available from C?
Code below. Thanks!
void RandomArray(std::vector<double> &data)
{
std::random_device rd{};
auto mtgen = std::mt19937{ rd() };
auto ud = std::uniform_int_distribution<>{ 1, 6 };
auto gen = [&ud, &mtgen](){ return ud(mtgen); };
std::generate(data.begin(), data.end(), gen);
}

Answer 1

You can use the extern "C" statement to make the function linkable to C code.
But working from your C++ version to the C version is harder I think, it would go something like this:
void RandomArray(std::vector<double> &data)
{
std::random_device rd{};
auto mtgen = std::mt19937{ rd() };
auto ud = std::uniform_int_distribution<>{ 1, 6 };
auto gen = [&ud, &mtgen](){ return ud(mtgen); };
std::generate(data.begin(), data.end(), gen);
}
extern "C" void RandomArray(double* data, size_t size)
{
std::vector<double> v(size);
RandomArray(v);
std::copy(std::begin(v), std::end(v), data); // need to copy out
}
Personally I would go the other way and make the C version the main algorithm and get the C++ version to call that:
extern "C" void RandomArray(double* data, size_t size)
{
std::random_device rd{};
auto mtgen = std::mt19937{ rd() };
auto ud = std::uniform_int_distribution<>{ 1, 6 };
auto gen = [&ud, &mtgen](){ return ud(mtgen); };
std::generate(data, data + size, gen);
}
void RandomArray(std::vector<double>& data)
{
RandomArray(data.data(), data.size());
}
Also it would be a lot faster not to initialize the random generator each time you call the function. One way to do that is making the random generator static. If you need thread safety you could also make it thread_local:
extern "C" void RandomArray(double* data, size_t size)
{
thread_local static auto mtgen = std::mt19937{std::random_device{}()};
auto ud = std::uniform_int_distribution<>{ 1, 6 };
std::generate(data, data + size, [&ud](){ return ud(mtgen); });
}

Answer 2

While C++ has standard support to call C functions, the reverse is not true. The only way to call a C++ function from C code is to make it C-compatible and use the C++ facilities to call it as a C function (only the function internal body code is C++ code), and compile it with a C++ compiler, to produce a C++ object code that has a C entry point
mod.h
#ifdef __cplusplus
extern "C" {
#endif
void my_function(const char *sample_parameter1, const int sample_parameter2);
#ifdef __cplusplus
}
#endif
mod.cc
#include <iostream>
#include "mod.h"
void my_function(const char *sample_parameter1, const int sample_parameter2)
{
std::cout << sample_parameter1
<< ", "
<< sample_parameter2
<< std::endl;
}
And then
main.c
#include <stdlib.h>
#include "mod.h"
int main()
{
my_function("Sample literal 1", 37);
exit(EXIT_SUCCESS);
}
To compile this, you need the following sequence:
$ c++ -o mod.o -c mod.cc
$ cc -o main.o -c main.c
$ c++ main.o mod.cc
$ a.out
(You need to invoque c++ to make the link phase, as it needs to include the standard c++ modules required at link time)
As far as you have included a c++ module, the whole project must be considered a c++ project and not C, because you'll need the C++ runtime modules to initialize properly all the global c++ objects you declare in your c++ modules and to include the c++ libraries you may use. You'll only compile with the cc C compiler only the modules that are pure C (and you have to use the C++ rules to distinguish them as C code)
The c++ compiler uses a different naming procedure for identifiers and all the C identifiers must be marked extern "C" (that's the reason of the mod.h file) If you don't follow that you'll lead to a unknown function 'my_function' linker message because C++ names include information about the parameter list types used in them, to allow for overloaded function names.