SECTION [29]: How to mix C and C++

[29.1] What do I need to know when mixing C and C++ code?

There are several caveats:
1. Your must use your C++ compiler when compiling main( (e.g.! "or static
initiali#ation.
2. Your C++ compiler shoul$ $irect the lin%ing process (e.g.! so it can get
its special li&raries
'. Your C an$ C++ compilers pro&a&ly nee$ to come "rom same ven$or an$
have
compati&le versions (e.g.! so they have the same calling conventions
(n a$$ition! you)ll nee$ to rea$ the rest o" this section to *n$ out how to
ma%e your C "unctions calla&le &y C++ an$+or your C++ "unctions calla&le
&y C.
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.2] -ow can ( inclu$e a stan$ar$ C hea$er *le in my C++ co$e.
To /inclu$e a stan$ar$ hea$er *le (such as 0st$io.h1! you $on)t have to $o
anything unusual. 2.g.!
++ This is C++ co$e
/inclu$e 0st$io.h1 ++ 3ote: nothing unusual in /inclu$e line
main(
4
print"(5-ello worl$6n57 ++ 3ote: nothing unusual in the call
8
Note: 9omewhat $i:erent gui$elines apply "or non;system C hea$ers. There
are two cases: either you can)t change the hea$er [29.']! or you can change
the hea$er[29.<].
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.'] How can I inc!de a non"#$#tem C heade% &e in m$ C++ code?
(" you are inclu$ing a C hea$er *le that isn)t provi$e$ &y the system! you
may nee$ to wrap the /inclu$e line in an e=tern C 4 +>...>+ 8 construct. This
tells the C++ compiler that the "unctions $eclare$ in the hea$er *le are C
"unctions.
++ This is C++ co$e
e=tern 5C5 4
++ ?et $eclaration "or "(int i! char c! @oat =
/inclu$e 5my;C;co$e.h5
8
main(
4
"(A! )=)! '.1<7 ++ 3ote: nothing unusual in the call
8
Note: 9omewhat $i:erent gui$elines apply "or C hea$ers provi$e$ &y the
system (such as 0st$io.h1[29.2] an$ "or C hea$ers that you can change
[29.<].
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.<] -ow can ( mo$i"y my own C hea$er *les so it)s easier to /inclu$e
them in C++ co$e.
(" you are inclu$ing a C hea$er *le that isn)t provi$e$ &y the system! an$ i"
you are a&le to change the C hea$er! you shoul$ strongly consi$er a$$ing
the e=tern C 4...8 logic insi$e the hea$er to ma%e it easier "or C++ users to
/inclu$e it into their C++ co$e. 9ince a C compiler won)t un$erstan$ the
e=tern C construct! you must wrap the e=tern C 4 an$ 8 lines in an /i"$e" so
they won)t &e seen &y normal C compilers.
9tep /1: But the "ollowing lines at the very top o" your C hea$er *le (note:
the sym&ol CCcplusplus is /$e*ne$ i"+only;i" the compiler is a C++
compiler:
/i"$e" CCcplusplus
e=tern 5C5 4
/en$i"
9tep /2: But the "ollowing lines at the very &ottom o" your C hea$er *le:
/i"$e" CCcplusplus
8
/en$i"
3ow you can /inclu$e your C hea$er without any e=tern C nonsense in your
C++ co$e:
++ This is C++ co$e
++ ?et $eclaration "or "(int i! char c! @oat =
/inclu$e 5my;C;co$e.h5 ++ 3ote: nothing unusual in /inclu$e line
main(
4
"(A! )=)! '.1<7 ++ 3ote: nothing unusual in the call
8
Note: 9omewhat $i:erent gui$elines apply "or C hea$ers provi$e$ &y the
system (such as 0st$io.h1[29.2] an$ "or C hea$ers that you can)t
change[29.'].
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.D] -ow can ( call a non;system C "unction "( int! char! @oat "rom my C+
+ co$e.
(" you have an in$ivi$ual C "unction that you want to call! an$ "or some
reason you $on)t have or $on)t want to /inclu$e a C hea$er *le in which that
"unction is $eclare$! you can $eclare the in$ivi$ual C "unction in your C
co$e using the e=tern C synta=. 3aturally you nee$ to use the "ull "unction
prototype:
e=tern 5C5 voi$ "(int i! char c! @oat =7
E &loc% o" several C "unctions can &e groupe$ via &races:
e=tern 5C5 4
voi$ "(int i! char c! @oat =7
int g(char> s! const char> s27
$ou&le sFrtG"9umG"9Fuares($ou&le a! $ou&le &7
8
E"ter this you simply call the "unction Hust as i" it was a C++ "unction:
main(
4
"(A! )=)! '.1<7 ++ 3ote: nothing unusual in the call
8
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,
[29.I] -ow can ( create a C++ "unction "(int! char! @oat that is calla&le &y
my C co$e.
The C++ compiler must %now that "(int! char! @oat is to &e calle$ &y a C
compiler using the e=tern C construct[29.']:
++ This is C++ co$e
++ Jeclare "(int!char!@oat using e=tern C:
e=tern 5C5 voi$ "(int i! char c! @oat =7
++ ...
++ Je*ne "(int!char!@oat in some C++ mo$ule:
voi$ "(int i! char c! @oat =
4
++ ...
8
The e=tern C line tells the compiler that the e=ternal in"ormation sent to the
lin%er shoul$ use C calling conventions an$ name mangling (e.g.! prece$e$
&y a single un$erscore.9ince name overloa$ing isn)t supporte$ &y C! you
can)t ma%e several overloa$e$ "unctions simultaneously calla&le &y a C
program.
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.A] Khy is the lin%er giving errors "or C+C++ "unctions &eing calle$ "rom
C+++C "unctions.
(" you $i$n)t get your e=tern C right! you)ll sometimes get lin%er errors
rather than compiler errors. This is $ue to the "act that C++ compilers
usually 5mangle5 "unction names (e.g.! to support "unction overloa$ing
$i:erently than C compilers.
9ee the previous two LEMs on how to use e=tern C.
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.N] How can I 'a## an o()ect o* a C++ ca## to+*%om a C *!nction?
[,-./TE.O]
[Pecently a$$e$ /i"n$e" LP2JC- + /$e*ne LP2JC- to co$e (on 1+9A.]
-ere)s an e=ample ("or in"o on e=tern C! see the previous two LEMs.
Lre$.h:
+> This hea$er can &e rea$ &y &oth C an$ C++ compilers >+
/i"n$e" LP2JC-
/$e*ne LP2JC-
/i"$e" CCcplusplus
class Lre$ 4
pu&lic:
Lre$(7
voi$ wilma(int7
private:
int aC7
87
/else
type$e"
struct Lre$
Lre$7
/en$i"
/i"$e" CCcplusplus
e=tern 5C5 4
/en$i"
/i" $e*ne$(CC9TJCCC QQ $e*ne$(CCcplusplus
e=tern voi$ cC"unction(Lre$>7 +> E39(;C prototypes >+
e=tern Lre$> cplusplusCcall&ac%C"unction(Lre$>7
/else
e=tern voi$ cC"unction(7 +> RSP style >+
e=tern Lre$> cplusplusCcall&ac%C"unction(7
/en$i"
/i"$e" CCcplusplus
8
/en$i"
/en$i" +>LP2JC->+
Lre$.cpp:
++ This is C++ co$e
/inclu$e 5Lre$.h5
Lre$::Lre$( : aC(T 4 8
voi$ Lre$::wilma(int a 4 8
Lre$> cplusplusCcall&ac%C"unction(Lre$> "re$
4
"re$;1wilma(12'7
return "re$7
8
main.cpp:
++ This is C++ co$e
/inclu$e 5Lre$.h5
int main(
4
Lre$ "re$7
cC"unction(S"re$7
return T7
8
c;"unction.c:
+> This is C co$e >+
/inclu$e 5Lre$.h5
voi$ cC"unction(Lre$> "re$
4
cplusplusCcall&ac%C"unction("re$7
8
Bassing pointers to C++ o&Hects to+"rom C "unctions will "ail i" you pass an$
get &ac% something that isn)t e=actly the same pointer. Lor e=ample! $on)t
pass a &ase class pointer an$ receive &ac% a $erive$ class pointer! since your
C compiler won)t un$erstan$ the pointer conversions necessary to han$le
multiple an$+or virtual inheritance.
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.9] Can my C "unction $irectly access $ata in an o&Hect o" a C++ class.
9ometimes.
(Lor &asic in"o on passing C++ o&Hects to+"rom C "unctions! rea$ the
previous LEM.
You can sa"ely access a C++ o&Hect)s $ata "rom a C "unction i" the C++
class:
> -as no virtual[2T] "unctions (inclu$ing inherite$ virtual "unctions
> -as all its $ata in the same access;level section (private+protecte$+pu&lic
> -as no "ully;containe$ su&;o&Hects with virtual [2T] "unctions
(" the C++ class has any &ase classes at all (or i" any "ully containe$ su&;
o&Hects have &ase classes! accessing the $ata will technically &e non;
porta&le! since class layout un$er inheritance isn)t impose$ &y the language.
-owever in practice! all C++ compilers $o it the same way: the &ase class
o&Hect appears *rst (in le"t;to;right or$er in the event o" multiple
inheritance! an$ mem&er o&Hects "ollow.
Lurthermore! i" the class (or any &ase class contains any virtual "unctions!
almost all C++ compilers put a voi$> into the o&Hect either at the location o"
the *rst virtual "unction or at the very &eginning o" the o&Hect. Egain! this is
not reFuire$ &y the language! &ut it is the way 5everyone5 $oes it.
(" the class has any virtual &ase classes! it is even more complicate$ an$ less
porta&le. Gne common implementation techniFue is "or o&Hects to contain
an o&Hect o" the virtual &ase class (U last (regar$less o" where U shows up
as a virtual &ase class in the inheritance hierarchy. The rest o" the o&Hect)s
parts appear in the normal or$er. 2very $erive$ class that has U as a virtual
&ase class actually has a pointer to the U part o" the *nal o&Hect.
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,
[29.1T] Wh$ do I *ee ike I0m 1*!%the% *%om the machine1 in C++ a#
o''o#ed to C?
Vecause you are.
As an OO programming language, C++ allows you to model the problem domain itself, which
allows you to program in the language of the problem domain rather than in the language of the
solution domain.
Gne o" C)s great strengths is the "act that it has 5no hi$$en mechanism5:
what you see is what you get. You can rea$ a C program an$ 5see5 every
cloc% cycle. This is not the case in C++7 ol$ line C programmers (such as
many o" us once were are o"ten am&ivalent (can you say! 5hostile5. a&out
this "eature. -owever a"ter they)ve ma$e the transition to GG thin%ing! they
o"ten reali#e that although C++ hi$es some mechanism "rom the
programmer! it also provi$es a level o" a&straction an$ economy o"
e=pression which lowers maintenance costs without $estroying run;time
per"ormance.
3aturally you can write &a$ co$e in any language7 C++ $oesn)t guarantee
any particular level o" Fuality! reusa&ility! a&straction! or any other measure
o" 5goo$ness.5
C++ $oesn)t try to ma%e it impossi&le "or &a$ programmers to write &a$
programs7 it ena&les reasona&le $evelopers to create superior so"tware.
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,