C++中调用C程序的方法（转）
因为C＋＋和C是两种完全不同的编译链接处理方式，所以如果直接在C＋＋里面调用C函数，这样链接起来是通不过的，会报链接错误，找不到函数体，所以要在
C＋＋文件里面显示声明以下一些函数是C写的，要用C的方式来处理，这个在C＋＋设计初期就考虑到兼容性的问题，所以是可以解决的。
比如用C写了 A.h和A.c这两个文件，里面包括了void
A_app（int）这样的函数，那么在需要调用这个函数的CPP文件里面，就需要显示声明一下了。
1.引用头文件前需要加上 extern “C”，如果引用多个，那么就如下所示
extern “C”
#include “A.h”
#include “B.h”
#include “C.h”
#include “D.h”
然后在调用这些函数之前，需要将函数也全部声明一遍。
2.C++调用C函数的方法,将用到的函数全部重新声明一遍
extern “C”
extern void A_app（int）;
extern void B_app（int）;
extern void C_app（int）;
extern void D_app（int）;
C++程序中调用被c编译器编译后的函数，为什么要加extern "C"？
C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。
假设某个C 函数的声明如下：
void foo(int x, int y);
编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字用来支持函数重载和类型安全连接。由于编译后的名字不同，C++程序不能直接调用C
函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。
extern “C”
void foo(int x, int y);
// 其它函数
extern “C”
#include “myheader.h”
// 其它C 头文件
这就告诉C++编译译器，函数 foo 是个C 连接，应该到库中找名字_foo 而不是找
_foo_int_int。C++编译器开发商已经对C 标准库的头文件作了extern“C”处理，所以
我们可以用＃include 直接引用这些头文件
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。&&/&&&&/&&&&/&&&&/&&
类和对象是 C++ 的重要特性，它们使得 C++ 成为面向对象的编程语言，可以用来开发中大型项目，本节重点讲解类和对象的语法，如果你对它们的概念还不了解，请先阅读《》。
类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。
有些教程将类的成员变量称为类的属性（Property），将类的成员函数称为类的方法（Method）。在面向对象的编程语言中，经常把函数（Function）称为方法（Method）。
与结构体一样，类只是一种复杂数据类型的声明，不占用内存空间。而对象是类这种数据类型的一个变量，或者说是通过类这种数据类型创建出来的一份实实在在的数据，所以占用内存空间。
类是用户自定义的类型，如果程序中要用到类，必须提前说明，或者使用已存在的类（别人写好的类、标准库中的类等），C++语法本身并不提供现成的类的名称、结构和内容。
一个简单的类的定义：
class Student{
//成员变量
//成员函数
void say(){
cout&&name&&&的年龄是&&&age&&&，成绩是&&&score&&
class是 C++ 中新增的关键字，专门用来定义类。Student是类的名称；类名的首字母一般大写，以和其他的标识符区分开。{ }内部是类所包含的成员变量和成员函数，它们统称为类的成员（Member）；由{ }包围起来的部分有时也称为类体，和函数体的概念类似。public也是 C++ 的新增关键字，它只能用在类的定义中，表示类的成员变量或成员函数具有&公开&的访问权限，初学者请先忽略该关键字，我们将在《》中讲解。
注意在类定义的最后有一个分号;，它是类定义的一部分，表示类定义结束了，不能省略。
整体上讲，上面的代码创建了一个 Student 类，它包含了 3 个成员变量和 1 个成员函数。
类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。
类可以理解为一种新的数据类型，该数据类型的名称是 Student。与 char、int、float 等基本数据类型不同的是，Student 是一种复杂数据类型，可以包含基本类型，而且还有很多基本类型中没有的特性，以后大家会见到。
有了 Student 类后，就可以通过它来创建对象了，例如：
Student liL
//创建对象
Student是类名，liLei是对象名。这和使用基本类型定义变量的形式类似：
//定义整型变量
从这个角度考虑，我们可以把 Student 看做一种新的数据类型，把 liLei 看做一个变量。
在创建对象时，class 关键字可要可不要，但是出于习惯我们通常会省略掉 class 关键字，例如：
class Student LiL
Student LiL
//同样正确
除了创建单个对象，还可以创建对象数组：
Student allStu[100];
该语句创建了一个 allStu 数组，它拥有100个元素，每个元素都是 Student 类型的对象。
访问类的成员
创建对象以后，可以使用点号.来访问成员变量和成员函数，这和通过结构体变量来访问它的成员类似，如下所示：
#include &iostream&
//类通常定义在函数外面
class Student{
//类包含的变量
//类包含的函数
void say(){
cout&&name&&&的年龄是&&&age&&&，成绩是&&&score&&
int main(){
//创建对象
stu.name = &小明&;
stu.age = 15;
stu.score = 92.5f;
stu.say();
运行结果：
小明的年龄是15，成绩是92.5
stu 是一个对象，占用内存空间，可以对它的成员变量赋值，也可以读取它的成员变量。
类通常定义在函数外面，当然也可以定义在函数内部，不过很少这样使用。
使用对象指针
C语言中经典的指针在 C++ 中仍然广泛使用，尤其是指向对象的指针，没有它就不能实现某些功能。
上面代码中创建的对象 stu 在栈上分配内存，需要使用&获取它的地址，例如：
Student *pStu = &
pStu 是一个指针，它指向 Student 类型的数据，也就是通过 Student 创建出来的对象。
当然，你也可以在堆上创建对象，这个时候就需要使用前面讲到的new关键字，例如：
Student *pStu = new S
在栈上创建出来的对象都有一个名字，比如 stu，使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，否则以后再也无法找到这个对象了，更没有办法使用它。也就是说，使用 new 在堆上创建出来的对象是匿名的，没法直接使用，必须要用一个指针指向它，再借助指针来访问它的成员变量或成员函数。
栈内存是程序自动管理的，不能使用 delete 删除在栈上创建的对象；堆内存由程序员管理，对象使用完毕后可以通过 delete 删除。在实际开发中，new 和 delete 往往成对出现，以保证及时删除不再使用的对象，防止无用内存堆积。
栈（Stack）和堆（Heap）是 C/C++ 程序员必须要了解的两个概念，我们已在《》专题中进行了深入讲解，相信你必将有所顿悟。
有了对象指针后，可以通过箭头-&来访问对象的成员变量和成员函数，这和通过结构体指针来访问它的成员类似，请看下面的示例：
pStu -& name = &小明&;
pStu -& age = 15;
pStu -& score = 92.5f;
pStu -& say();
下面是一个完整的例子：
#include &iostream&
class Student{
void say(){
cout&&name&&&的年龄是&&&age&&&，成绩是&&&score&&
int main(){
Student *pStu = new S
pStu -& name = &小明&;
pStu -& age = 15;
pStu -& score = 92.5f;
pStu -& say();
//删除对象
运行结果：
小明的年龄是15，成绩是92.5
虽然在一般的程序中无视垃圾内存影响不大，但记得 delete 掉不再使用的对象依然是一种良好的编程习惯。
本节重点讲解了两种创建对象的方式：一种是在栈上创建，形式和定义普通变量类似；另外一种是在堆上创建，必须要用一个指针指向它，读者要记得 delete 掉不再使用的对象。
通过对象名字访问成员使用点号.，通过对象指针访问成员使用箭头-&，这和结构体非常类似。在C++中如何使用C
首先，分析下面的代码片段：// Demo.h
#ifndef SRC_DEMO_H
#define SRC_DEMO_H
extern "C"
// do something
// SRC_DEMO_H 显然，头文件中的编译宏“#ifndef SRC_DEMO_H、#define SRC_DEMO_H、#endif”的作用是防止该头文件被重复引用。那么，extern "C"又有什么特殊的作用呢？暂且先留着这个疑问。C++语言被称做“C with classes”、“a better C”或“C的超集合”，但是并非兼容C语言的所有东西，两者之间的“大同”并不能完全抹杀其中的“小异”。最常见的差异就是，C允许从void类型指针隐式转换成其他类型的指针，但C++为了安全考虑明令禁止了此种行为。比如：如下代码在C语言中是有效的：// 从void* 隐式转换为double*
double *pDouble = malloc(nCount * sizeof(double)); 但要使其在C++中正确运行，就需要显式地转换：double *pDouble = (double *)malloc(nCount * sizeof(double)); 除此之外，还有一些其他的可移植问题，比如new和class在 C++中是关键字，而在C中，却可以作为变量名。若想在C++中使用大量现成的C程序库，就必须把它放到extern "C" { /* code */ }中。到这里，也许大家会茅塞顿开，明白本建议开始列出的代码片段中那些宏的真实作用了。当然，具有强烈好奇心的读者也许会有了新的问题：为什么加上extern "C" { /* code */ }就好使了呢？这是一个问题。下面就分析一下隐藏在这个现象背后的真实原因：C与C++具有不同的编译和链接方式。C编译器编译函数时不带函数的类型信息，只包含函数符号名字；而C++编译器为了实现函数重载，在编译时会带上函数的类型信息。假设某个函数的原型为：int Function(int a, float b); C编译器把该函数编译成类似_ Function的符号（这种符号一般被称为mangled name），C链接器只要找到了这个符号，就可以连接成功，实现调用。C编译链接器不会对它的参数类型信息加以验证，只是假设这些信息是正确的，这正是C编译链接器的缺点所在。而在强调安全的C++中，编译器会检查参数类型信息，上述函数原型会被编译成_ Function_int_float这样的符号（也正是这种机制为函数重载的实现提供了必要的支持）。在连接过程中，链接器会在由函数原型所在模块生成的目标文件中寻找_ Function_int_float这样的符号。解决上述矛盾就成了设置extern "C"这一语法最直接的原因与动力。extern "C"的作用就是告诉C++链接器寻找调用函数的符号时，采用C的方式，让编译器寻找_ Function而不是_ Function_int_float。要实现在C++中调用C的代码，具体方式有以下几种：（1）修改C代码的头文件，当其中含有C++代码时，在声明中加入extern "C"。代码如下所示：/*C语言头文件：CDemo.h */
#ifndef C_SRC_DEMO_H
#define C_SRC_DEMO_H
extern "C" int Function(int x,int y);
// C_SRC_DEMO_H
/* C语言实现文件：CDemo.c */
#include " CDemo.h"
int Function ( int x, int y )
... // processing code
// C++调用文件
#include " CDemo.h"
int main()
Function (2,3);
} （2）在C++代码中重新声明一下C函数，在重新声明时添加上extern "C"。代码如下所示： /*C语言头文件：CDemo.h */
#ifndef C_SRC_DEMO_H
#define C_SRC_DEMO_H
extern int Function(int x,int y);
// C_SRC_DEMO_H
/* C语言实现文件：CDemo.c */
#include "CDemo.h"
int Function ( int x, int y )
... // processing code
// C++调用文件
#include "CDemo.h"
extern "C" int Function(int x,int y);
int main()
Function (2,3);
} （3）在包含C头文件时，添上extern "C"。代码如下所示：/*C语言头文件：CDemo.h */
#ifndef C_SRC_DEMO_H
#define C_SRC_DEMO_H
extern int Function(int x,int y);
// C_SRC_DEMO_H
/* C语言实现文件：CDemo.c */
#include "CDemo.h"
int Function ( int x, int y )
... // processing code
// C++调用文件
extern "C" {
#include "CDemo.h"
int main()
Function (2,3);
} 使用中，谨记： extern "C"一定要加在C++的代码文件中才能起作用。请记住：若想在C++中使用大量现成的C程序库，实现C++与C的混合，那你必须了解extern "C"是怎么回事儿，明白extern "C"的使用方式。
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'6108人阅读
本文给出了一种方法。基本思想是，写一个 wrapper文件，把 C++类封装起来，对外只提供C语言的接口，和 C++i相关的都在& wrapper的实现文件里实现。
1. apple.h
#ifndef __APPLE_H__
#define __APPLE_H__
class Apple
APPLE_COLOR_RED,
APPLE_COLOR_BLUE,
APPLE_COLOR_GREEN,
int GetColor(void);
void SetColor(int color);
apple.cpp:
#include &apple.h&
Apple::Apple():m_nColor(APPLE_COLOR_RED)
void Apple::SetColor(int color)
m_nColor =
int Apple::GetColor(void)
return m_nC
2. AppleWrapper.h
#ifndef _APPLE_WRAPPER_H__
#define _APPLE_WRAPPER_H_
struct tagA
#ifdef __cplusplus
extern &C& {
struct tagApple *GetInstance(void);
void ReleaseInstance(struct tagApple **ppInstance);
extern void SetColor(struct tagApple *pApple, int color);
extern int GetColor(struct tagApple *pApple);
#ifdef __cplusplus
AppleWrapper.cpp
#include &AppleWrapper.h&
#include &apple.h&
#ifdef __cplusplus
extern &C& {
struct tagApple
struct tagApple *GetInstance(void)
return new struct tagA
void ReleaseInstance(struct tagApple **ppInstance)
delete *ppI
*ppInstance = 0;
void SetColor(struct tagApple *pApple, int color)
pApple-&apple.SetColor(color);
int GetColor(struct tagApple *pApple)
return pApple-&apple.GetColor();
#ifdef __cplusplus
#include &AppleWrapper.h&
#include &assert.h&
int main(void)
struct tagApple * pA
pApple= GetInstance();
SetColor(pApple, 1);
int color = GetColor(pApple);
printf(&color = %d\n&, color);
ReleaseInstance(&pApple);
assert(pApple == 0);
可以用 GCC编译：
g++ -c apple.cpp
g++ -c apple.cpp
AppleWrapper.cpp
gcc test.c -o test AppleWrapper.o apple.o -lstdc++
其实，& wrapper里的 struct 完全可以不要，定义一个& handle更好：
#ifndef _APPLE_WRAPPER_H__
#define _APPLE_WRAPPER_H_
#ifdef __cplusplus
extern &C& {
GetInstance(int *handle);
void ReleaseInstance(int *handle);
extern void SetColor(int handle, int color);
extern int GetColor(int handle);
#ifdef __cplusplus
#include &AppleWrapper.h&
#include &apple.h&
#include &vector&
#ifdef __cplusplus
extern &C& {
static std::vector&Apple *& g_appleV
int GetInstance(int * handle)
g_appleVector[0] =
*handle = 0;
void ReleaseInstance(int *handle)
delete g_appleVector[*handle];
*handle = -1;
void SetColor(int handle, int color)
g_appleVector[handle]-&SetColor(color);
int GetColor(int handle)
return g_appleVector[handle]-&GetColor();
#ifdef __cplusplus
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：553038次
积分：8464
积分：8464
排名：第1800名
原创：279篇
转载：160篇
评论：31条
(2)(1)(7)(2)(2)(4)(17)(21)(13)(7)(1)(1)(11)(3)(6)(13)(8)(7)(10)(16)(7)(17)(7)(33)(11)(22)(10)(18)(11)(6)(6)(11)(8)(9)(3)(3)(10)(10)(8)(10)(3)(4)(11)(7)(3)(5)(1)(1)(4)(3)(4)(5)(4)(8)(2)(2)(4)(4)(2)(5)(2)(3)(2)