filoj@pc.ecn.purdue.edu (Jeffrey J Filo) (11/13/89)
I have had complete success calling C++ libraries I have written
from ANSI C and FORTRAN77. My work in surface modeling lends itself
to an object-oriented implementation but I am required to retrofit
the modeler into existing FORTRAN code. Since this audience is
probably more comfortable with the C language, my examples will be
written in C.
The way to do this is to "wrap" each C++ method in a C function.
An example of this is the method _Sort_ in the class _List_. Say
there is a class _List_ which has a method _Sort_. The class
definition would look as follows:
class List {
private:
... some data
public:
... more data
List( );
void Sort( );
};
In a C++ program, the method Sort would be called as follows:
main() {
List *aList;
aList = new List;
List->Sort();
}
A C language program, however, has no knowledge of objects and
object pointers. The solution is to treat the object pointers as
integers as follows:
main() {
int aList;
aList = NewList( );
SortList( aList );
}
The functions _NewList_ and _SortList_ are wrapped around the class
methods:
int NewList( ) {
List *aList;
aList = new List;
return( (int)aList );
}
void SortList( int A ) {
List *aList;
aList = (List *)A;
aList->Sort();
}
The C code treats the C++ object as an integer and the turnaround
functions type cast it back into its correct type before invoking the
object method.
It can be argued that this sort of typecasting is a generally bad idea,
except that it is _completely_analogous_ to the way C structures are
treated by FORTRAN in C/FORTRAN cross-compilings.
What is required of the developer, then, is to write a turnaround
function for each object method. An unfortunate side-effect is the loss
of function overloading and I am open to suggestions on how to avoid this.
Lastly, global objects must be initialized in an Init function since you
cannot rely on the compiler doing this for you. I usually write a function
that initializes all of the global objects and have gotten in the habit
of doing this even when using C++ only.
In summary, it is straight-forward, though not elegant, to write an
interface that will allow C++ routines to be called from C or FORTRAN
code. Once the interface is compiled with C++, the other compilers
will correctly link the C++ library to standard code.
----
Jeff Filo
School of Mechanical Engineering
Purdue University
filoj@ecn.purdue.edu