Re: I wish c++ did interfaces better.
"James Kanze" <james.kanze@gmail.com> wrote in message =
news:dc62d088-11d9-4bd7-bf22-8f96a02c5374@2g2000hsn.googlegroups.com...
Well, Chris Becke did mention linking with other languages. If
that's going to work, the compiler has to lay out everything
(including vtables) in a compatible format (and the other
language has to support whatever it is you're trying to
do---virtual functions don't work too well in an `extern "C"',
for example).
Binary compatibility between "modules" that may have been compiled in =
different languages has always been a case of co-ercing the compliant =
compilers on the platform in question to produce compatible code.
So, Microsoft defines a technology called COM that relies on a table of =
function pointers to be passed between modules. These tables can be =
defined manually in C, as struct containing function pointers, each =
function takes a pointer to an object as its first parameter. In c++ its =
convenient to declare these interfaces by creating a struct / public =
class containing pure virtual functions - and later on implement the =
virtual functions in a derived class.
However, as it turns out, c++ makes these things horrible to extend, or =
have inheritable implement for.
Pointing out that c++ leaves the layout of vtables to implementations =
is, well, redundant as that was the point of my original post: I wish =
that c++ did interfaces better.
It's all very implementation defined. Generally, either the
compilers of both languages concure (and you use `extern
"Whatever"' in C++, to tell the compiler that it has to follow
the conventions of the other language), or you have to use some
external tool such as Corba. In a lot of cases, the only thing
different languages will support is the C API, which means that
anything passed between them must be C compatible. If the other
language does provide the equivalent of an `extern "C++"', it's
possible that it still imposes some restrictions (no templates
would seem likely, but no virtual inheritance, or even no
multiple inheritance, is also a distinct possibility). In some
cases (Java's JNI, for example), the other language defines what
the interface will look like, and your C++ code has to conform;
I'm pretty sure that JNI supports virtual functions in C++, but
I'm also pretty sure that either it doesn't allow multiple
inheritance, or it imposes severe restrictions on it. And
external tools will impose their own constraints.
None of which, of course, is really relevant here. If you're
using tools which impose artificial constraints on the language,
that's not really C++ (and you should seriously think about
changing the tool set).
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34