gas@cs.nott.ac.uk (Alan Shepherd) (04/16/91)
From my understanding, the correct way to make C++ functions
accessible from modules compiled with c is to delcare them extern "C"
as in the following example:
#include <stream.h>
extern "C" void tryCout();
void tryCout()
{
cout << "Hello World\n";
}
Now this can be called from a program compiled with cc. For example,
the following program:
extern void tryCout();
main()
{
tryCout();
}
This happily compiles without any warnings. However, when running, a
segv occurs in the cout operation. This segv disappears if both
modules are compiled with CC instead of just the first. Adding
another level of indirection to the code by writing another function
to call tryCout doesn't work either.
Is this a bug ? It certainly looks like it !
Alan Shepherdgribble@ogre.cica.indiana.edu (04/18/91)
I think you have it backwards--use extern to link C functions to C++. It has to do w/ "name-mangling"--something C++ does to function names. -- ************************************************************************** * Steve Gribble (812) 855-9172/7629 gribble@cica.cica.indiana.edu * Systems Manager, Inst. of Social Research swg@socmail.soc.indiana.edu * Dept. of Sociology, Indiana University gribble@iubacs
jac@gandalf.llnl.gov (James A. Crotinger) (04/18/91)
I'm not certain, but I believe that in order to use streams,
the main() program needs to be written in C++. The problem is
that cout is a globally declared class which must be initialized
before main() is called. This won't happen if the main() is
written in C. For example, the following works fine on my Sun
(using Sun C 1.0 and Sun C++ 2.0).
-----------------------------------
// main.cc
#include <stream.h>
extern "C" void foo(void);
extern "C" void bar(void);
main()
{
bar();
}
void foo()
{
cout << "Testing...\n";
}
-----------------------------------
/* bar.c */
extern void foo();
void bar()
{
foo();
}
-----------------------------------
Jim
--
-----------------------------------------------------------------------------
James A. Crotinger Lawrence Livermore Natl Lab // The above views
jac@moonshine.llnl.gov P.O. Box 808; L-630 \\ // are mine and are not
(415) 422-0259 Livermore CA 94550 \\/ necessarily those of LLNLhaydens@natasha.juliet.ll.mit.edu (Hayden Schultz) (04/18/91)
I'm pretty sure that Jim (jac@gandalf.llnl.gov) has the right answer, that because the C++ main does tricky things like call global constructors that the original C main didn't call. So it makes sense that when you try to access a global object that hasn't been initialized correctly, like cout, you get a segv. But isn't there some way to explicitly invoke the global constructors and destructors so you can use a C main and call C++ routines? I can't manage to accomplish this with Sun CC. It would be very nice if I could use C++ routines everywhere I use C routines. For example, I can call C routines from lisp, but since it doesn't have a C++ main, I can't figure out how to call C++ routines. Hayden Schultz (haydens@juliet.ll.mit.edu) MIT Lincoln Lab
steve@taumet.com (Stephen Clamage) (04/18/91)
gas@cs.nott.ac.uk (Alan Shepherd) writes: >#include <stream.h> >extern "C" void tryCout(); >void tryCout() >{ > cout << "Hello World\n"; >} >Now this can be called from a program compiled with cc. For example, >the following program: >extern void tryCout(); >main() >{ > tryCout(); >} >This happily compiles without any warnings. However, when running, a >segv occurs in the cout operation. This segv disappears if both >modules are compiled with CC instead of just the first. Almost all current C++ compilers require that main() be compiled by the C++ compiler, even if other modules are compiled with a compatbile C compiler. Your compiler manual should tell you this. In general, C++ programs will require initialization of static objects via their constructors at runtime; cout is such an object. The C++ compiler arranges for the constructors (and destructors) to be called via special code emitted in the module in which main() appears. This ensures the special code is emitted and called exactly once. In your example, main() was not compiled by the C++ compiler, cout was not initialized, and the program failed when it tried to use member functions of cout. -- Steve Clamage, TauMetric Corp, steve@taumet.com
grp@Unify.com (Greg Pasquariello) (04/20/91)
In article <1991Apr16.122905.23613@cs.nott.ac.uk>, gas@cs.nott.ac.uk (Alan Shepherd) writes: > > From my understanding, the correct way to make C++ functions > accessible from modules compiled with c is to delcare them extern "C" > as in the following example: > > #include <stream.h> > > extern "C" void tryCout(); > > void tryCout() > { > cout << "Hello World\n"; > } > > Now this can be called from a program compiled with cc. For example, > the following program: > > extern void tryCout(); > > main() > { > tryCout(); > } > > This happily compiles without any warnings. However, when running, a > segv occurs in the cout operation. This segv disappears if both > modules are compiled with CC instead of just the first. Adding > another level of indirection to the code by writing another function > to call tryCout doesn't work either. > > Is this a bug ? It certainly looks like it ! You need to declare, in your C++ source code, an object of class Iostream_init. The constructor for the class will initialize cin, cout, cerr, and clog, and your core dump will go away. Note that this relies on C++ 2.0 and the iostreams package. To try it out, do: #include <iostream.h> extern "C" void tryCout(); void tryCout() { Iostream_init io; cout << "Hello World\n"; } On the C side: extern void tryCout(); main() { tryCout(); } > Alan Shepherd -- --- Greg Pasquariello grp@unify.com Unify Corporation Be good and never poison people
steve@taumet.com (Stephen Clamage) (04/21/91)
haydens@natasha.juliet.ll.mit.edu (Hayden Schultz) writes: >But isn't there some way to explicitly invoke the global constructors >and destructors so you can use a C main and call C++ routines? I can't >manage to accomplish this with Sun CC. There is no portable way to do this now. The ANSI C++ committee X3J16 is investigating ways to accomplish this. -- Steve Clamage, TauMetric Corp, steve@taumet.com
niklas@appli.se (Niklas Hallqvist) (04/21/91)
haydens@natasha.juliet.ll.mit.edu (Hayden Schultz) writes: >I'm pretty sure that Jim (jac@gandalf.llnl.gov) has the right answer, >that because the C++ main does tricky things like call global >constructors that the original C main didn't call. So it makes sense >that when you try to access a global object that hasn't been >initialized correctly, like cout, you get a segv. >But isn't there some way to explicitly invoke the global constructors >and destructors so you can use a C main and call C++ routines? I can't >manage to accomplish this with Sun CC. >It would be very nice if I could use C++ routines everywhere I use C >routines. For example, I can call C routines from lisp, but since it >doesn't have a C++ main, I can't figure out how to call C++ routines. Yes, that's tricky, but it ought to be possible with a little hacking. If your lisp implementation supports calling lisp functions from C/C++, and you have a binary editor, you should be able to patch in another name for the C++ "main", e.g "cppm" or something like that, and then call it from lisp the usual way. When this "main" gets called it should execute the global constructors for your C++ program, and then do a callback to your lisp function, which later will call other C++ functions. At the time of the return of this callback function the C++ "main" should execute the global destuctors before returning to lisp. This is of course very unportable since not every compiler puts the global constructor calling in "main", but rather before "main" is called, though I think AT&T derived C++ implementations will do it inside main. I also think that a binary editor won't be necessary in such implementations since they generate C output which could be edited with e.g. a sed script to change the name of the "main" function. Hope this helps Niklas -- Niklas Hallqvist Phone: +46-(0)31-40 75 00 Applitron Datasystem Fax: +46-(0)31-83 39 50 Molndalsvagen 95 Email: niklas@appli.se S-412 63 GOTEBORG, Sweden mcsun!sunic!chalmers!appli!niklas
grp@Unify.com (Greg Pasquariello) (04/22/91)
In article <675@taumet.com>, steve@taumet.com (Stephen Clamage) writes: > > Almost all current C++ compilers require that main() be compiled by > the C++ compiler, even if other modules are compiled with a compatbile > C compiler. Your compiler manual should tell you this. > > In general, C++ programs will require initialization of static objects > via their constructors at runtime; cout is such an object. The C++ > compiler arranges for the constructors (and destructors) to be called > via special code emitted in the module in which main() appears. This > ensures the special code is emitted and called exactly once. Only if some objects need initialization, and cannot provide it themselves! Iostreams with 2.0 provide an initializer object, called Iostream_init, so there is no reason you cannot use it unless you don't have the iostream library or a similar method of initializing your objects. It's true, I read it in the manual! :-) > > In your example, main() was not compiled by the C++ compiler, cout > was not initialized, and the program failed when it tried to use > member functions of cout. > -- > > Steve Clamage, TauMetric Corp, steve@taumet.com -- --- Greg Pasquariello grp@unify.com Unify Corporation Be good and never poison people
tell@oscar.cs.unc.edu (Stephen Tell) (04/24/91)
In article <1991Apr22.081254@Unify.com> grp@Unify.com (Greg Pasquariello) writes: >In article <675@taumet.com>, steve@taumet.com (Stephen Clamage) writes: >> >> Almost all current C++ compilers require that main() be compiled by >> the C++ compiler, even if other modules are compiled with a compatbile >> C compiler. Your compiler manual should tell you this. >> >> In general, C++ programs will require initialization of static objects >> via their constructors at runtime; cout is such an object. The C++ >> compiler arranges for the constructors (and destructors) to be called >> via special code emitted in the module in which main() appears. This >> ensures the special code is emitted and called exactly once. >[Iostreams with 2.0 provide an initializer object...] >[but not all class libraries do] >> In your example, main() was not compiled by the C++ compiler, cout >> was not initialized, and the program failed when it tried to use >> member functions of cout. Another C++ hacker and I figured out a way to do this for a simulator that was written in C and allows user code to be linked in with the program. Patch the .o files from the system so that the C main is renamed to somthing like "MaIn." Write short C++ file consisting of: extern "C" MaIn(int argc; char **argv); main(int argc, char **argv) { return MaIn(argc, argv); } This way, the real main is written in C++ and the constructors get called. The other code that you link in with the system can then be C++ and use whatever classes it likes since static objects will have had their constructors called. This may not be ideal, but it works. We did the C++ stuff with g++. I don't know what C compiler the original program was written with. It requires that the product be shipped with ordinary .o files that you run "ld" on to make customized versions, instead of funky schemes to attach user code to a running program. >> Steve Clamage, TauMetric Corp, steve@taumet.com >Greg Pasquariello grp@unify.com >Unify Corporation Be good and never poison people Steve -- Steve Tell tell@cs.unc.edu H: +1 919 968 1792 #5L Estes Park apts CS Grad Student, UNC Chapel Hill. W: +1 919 962 1845 Carrboro NC 27510 Duke Blue Devils: 1991 NCAA Basketball National Champions! We're Number 1 !! UNLV 90-91 record: "34 and DUKE."
bright@nazgul.UUCP (Walter Bright) (04/27/91)
In article <675@taumet.com>, steve@taumet.com (Stephen Clamage) writes:
/ Almost all current C++ compilers require that main() be compiled by
/ the C++ compiler, even if other modules are compiled with a compatbile
/ C compiler.
/
/ In general, C++ programs will require initialization of static objects
/ via their constructors at runtime; cout is such an object. The C++
/ compiler arranges for the constructors (and destructors) to be called
/ via special code emitted in the module in which main() appears.
This is not the way Zortech C/C++ works. There, the static constructors
are called by the startup code before main() is called, so it doesn't
matter if main() was compiled with the C or the C++ compiler. In fact
the runtime library for the C compiler uses static constructors... (!).mike@taumet.com (Michael S. Ball) (04/29/91)
In article <306@nazgul.UUCP> bright@nazgul.UUCP (Walter Bright) writes: >In article <675@taumet.com>, steve@taumet.com (Stephen Clamage) writes: >/ In general, C++ programs will require initialization of static objects >/ via their constructors at runtime; cout is such an object. The C++ >/ compiler arranges for the constructors (and destructors) to be called >/ via special code emitted in the module in which main() appears. > >This is not the way Zortech C/C++ works. There, the static constructors >are called by the startup code before main() is called, so it doesn't >matter if main() was compiled with the C or the C++ compiler. In fact In fact, C++ compilers which define their own linker format, or which have access to a linker format which provides multiple named sections (psects, etc) can and should do it this way. The Borland C++ system does exactly that, as does the Oregon Software VMS compiler. Unfortunately, the majority of the C++ implementations for other environments are forced to cope with the antequated UNIX linkers which don't give you any way to do this. It appears that ELF will finally let UNIX implementors handle initialization rationally. The consequence is that the majority of different C++ compilers require that the main program be compiled with C++, while those compilers with the largest number of instances each (MSDOS compilers) don't. On a UNIX-oriented network, Steve's comments are accurate. -- Michael S. Ball mike@taumet.com TauMetric Corporation (619)697-7607