How do I call a C function from C++?
Just declare the C function ``extern "C"'' (in your C++ code) and call it(from your C or C++ code). For example:
// C++ codeThe definitions of the functions may look like this:
extern "C" void f(int); // one way
extern "C" { // another way
int g(double);
double h();
};
void code(int i, double d)
{
f(i);
int ii = g(d);
double dd = h();
// ...
}
/* C code: */Note that C++ type rules, not C rules, are used. So you can't call function declared ``extern "C"''
void f(int i)
{
/* ... */
}
int g(double d)
{
/* ... */
}
double h()
{
/* ... */
}
with the wrong number of argument. For example:
// C++ code
void more_code(int i, double d)
{
double dd = h(i,d); // error: unexpected arguments
// ...
}
How do I call a C++ function from C?
Just declare the C++ function ``extern "C"'' (in your C++ code) andcall it (from your C or C++ code). For example:
// C++ code:Now f() can be used like this:
extern "C" void f(int);
void f(int i)
{
// ...
}
/* C code: */Naturally, this works only for non-member functions. If you want to call
void f(int);
void cc(int i)
{
f(i);
/* ... */
}
member functions (incl. virtual functions) from C, you need to provide
a simple wrapper. For example:
// C++ code:Now C::f() can be used like this:
class C {
// ...
virtual double f(int);
};
extern "C" double call_C_f(C* p, int i) // wrapper function
{
return p->f(i);
}
/* C code: */If you want to call overloaded functions from C, you must provide wrappers with distinct names
double call_C_f(struct C* p, int i);
void ccc(struct C* p, int i)
{
double d = call_C_f(p,i);
/* ... */
}
for the C code to use. For example:
// C++ code:Now the f() functions can be used like this:
void f(int);
void f(double);
extern "C" void f_i(int i) { f(i); }
extern "C" void f_d(double d) { f(d); }
/* C code: */Note that these techniques can be used to call a C++ library from C code
void f_i(int);
void f_d(double);
void cccc(int i,double d)
{
f_i(i);
f_d(d);
/* ... */
}
even if you cannot (or do not want to) modify the C++ headers.