GCC编译C C++ 和C混合C++

原文 http://blog.renren.com/share/241565115/1819139547

http://wiki.ubuntu.com.cn/Compiling_C#C_.E7.BC.96.E7.A8.8B.E4.B8.AD.E7.9B.B8.E5.85.B3.E6.96.87.E4.BB.B6.E5.90.8E.E7.BC.80

 

http://wiki.ubuntu.com.cn/Compiling_Cpp#C.2B.2B_.E7.BC.96.E7.A8.8B.E4.B8.AD.E7.9B.B8.E5.85.B3.E6.96.87.E4.BB.B6.E5.90.8E.E7.BC.80

http://wiki.ubuntu.com.cn/Mix_C_Cpp

C++ 编程中相关文件后缀

.a

静态库 (archive)

.C
.c
.cc
.cp
.cpp
.cxx
.c++

C++源代码（需要编译预处理）

.h

C或者C++源代码头文件

.ii

C++源代码（不需编译预处理）

.o

对象文件

.s

汇编语言代码

.so

动态库

<none>

标准C++系统头文件

单个源文件生成可执行程序

下面是一个保存在文件helloworld.cpp 中一个简单的 C++ 程序的代码：

点击(此处)折叠或打开

1.    /*helloworld.cpp */

2.    #include<iostream>

3.    int main(int argc,char*argv[])

4.    {

5.    std::cout<<"hello, world"<< std::endl;

6.      return(0);

7.    }

 

程序使用定义在头文件iostream 中的 cout，向标准输出写入一个简单的字符串。该代码可用以下命令编译为可执行文件：

$ g++ helloworld.cpp

编译器 g++ 通过检查命令行中指定的文件的后缀名可识别其为 C++ 源代码文件。编译器默认的动作：编译源代码文件生成对象文件(objectfile)，链接对象文件和libstdc++ 库中的函数得到可执行程序。然后删除对象文件。由于命令行中未指定可执行程序的文件名，编译器采用默认的 a.out。程序可以这样来运行：

$ ./a.out hello, world

更普遍的做法是通过 -o 选项指定可执行程序的文件名。下面的命令将产生名为helloworld 的可执行文件：

$ g++ helloworld.cpp -o helloworld

在命令行中输入程序名可使之运行：

$ ./helloworld hello, world

程序 g++ 是将 gcc 默认语言设为 C++ 的一个特殊的版本，链接时它自动使用 C++ 标准库而不用 C 标准库。通过遵循源码的命名规范并指定对应库的名字，用 gcc 来编译链接 C++ 程序是可行的，如下例所示：

$ gcc helloworld.cpp -lstdc++ -o helloworld

选项 -l(ell) 通过添加前缀 lib 和后缀 .a 将跟随它的名字变换为库的名字libstdc++.a。而后它在标准库路径中查找该库。gcc 的编译过程和输出文件与 g++ 是完全相同的。

在大多数系统中，GCC 安装时会安装一名为 c++ 的程序。如果被安装，它和 g++ 是等同，如下例所示，用法也一致：

$ c++ helloworld.cpp -o helloworld []多个源文件生成可执行程序

如果多于一个的源码文件在 g++ 命令中指定，它们都将被编译并被链接成一个单一的可执行文件。下面是一个名为speak.h 的头文件；它包含一个仅含有一个函数的类的定义：

 

点击(此处)折叠或打开

1. /* speak.h*/

2. #include <iostream>

3. class Speak {

4.  public: voidsayHello(constchar*);

5.  };

 

下面列出的是文件speak.cpp 的内容：包含sayHello() 函数的函数体：

 

 

点击(此处)折叠或打开

1.    /* speak.cpp */

2.    #include"speak.h"

3.    voidSpeak::sayHello(const char*str)

4.    { 

5.                std::cout<<"Hello" << str<< "\n";

6.    }

 

文件hellospeak.cpp 内是一个使用 Speak类的程序：

 

1.    /*hellospeak.cpp */

2.     #include"speak.h" 

3.    int main(int argc,char*argv[])

4.    { 

5.                Speak speak; 

6.                speak.sayHello("world"); 

7.                return(0); 

8.    }

 

下面这条命令将上述两个源码文件编译链接成一个单一的可执行程序：

$ g++ hellospeak.cpp speak.cpp -o hellospeak

PS：这里说一下为什么在命令中没有提到“speak.h“该文件（原因是：在“speak.cpp“中包含有”#include"speak.h"“这句代码，它的意思是搜索系统头文件目录之前将先在当前目录中搜索文件“speak.h“。而”speak.h“正在该目录中，不用再在命令中指定了）。

[编辑]源文件生成对象文件

选项 -c 用来告诉编译器编译源代码但不要执行链接，输出结果为对象文件。文件默认名与源码文件名相同，只是将其后缀变为 .o。例如，下面的命令将编译源码文件hellospeak.cpp 并生成对象文件hellospeak.o：

$ g++ -c hellospeak.cpp

命令 g++ 也能识别 .o 文件并将其作为输入文件传递给链接器。下列命令将编译源码文件为对象文件并将其链接成单一的可执行程序：

$ g++ -c hellospeak.cpp 

$ g++ -c speak.cpp 

$ g++ hellospeak.o speak.o -o hellospeak

选项 -o 不仅仅能用来命名可执行文件。它也用来命名编译器输出的其他文件。例如：除了中间的对象文件有不同的名字外，下列命令生将生成和上面完全相同的可执行文件：

$ g++ -c hellospeak.cpp -o hspk1.o

$ g++ -c speak.cpp -o hspk2.o

$ g++ hspk1.o hspk2.o -o hellospeak [编辑]编译预处理

选项 -E 使 g++ 将源代码用编译预处理器处理后不再执行其他动作。下面的命令预处理源码文件helloworld.cpp 并将结果显示在标准输出中：

$ g++ -E helloworld.cpp

本文前面所列出的helloworld.cpp 的源代码，仅仅有六行，而且该程序除了显示一行文字外什么都不做，但是，预处理后的版本将超过 1200 行。这主要是因为头文件iostream 被包含进来，而且它又包含了其他的头文件，除此之外，还有若干个处理输入和输出的类的定义。

预处理过的文件的 GCC 后缀为 .ii，它可以通过 -o 选项来生成，例如：

$ gcc -E helloworld.cpp -o helloworld.ii [编辑]生成汇编代码

选项 -S 指示编译器将程序编译成汇编语言，输出汇编语言代码而後结束。下面的命令将由 C++ 源码文件生成汇编语言文件helloworld.s：

$ g++ -S helloworld.cpp

生成的汇编语言依赖于编译器的目标平台。

[编辑]创建静态库

静态库是编译器生成的一系列对象文件的集合。链接一个程序时用库中的对象文件还是目录中的对象文件都是一样的。库中的成员包括普通函数，类定义，类的对象实例等等。静态库的另一个名字叫归档文件(archive)，管理这种归档文件的工具叫 ar 。

在下面的例子中，我们先创建两个对象模块，然后用其生成静态库。

头文件 say.h包含函数 sayHello()的原型和类 Say的定义：

 

1.    /* say.h */

2.    #include<iostream> 

3.    voidsayhello(void); 

4.    class Say

5.    { 

6.                private: char*string; 

7.                public: Say(char*str) 

8.                { 

9.                  string = str; 

10.              } 

11.              void sayThis(const char*str)

12.              { 

13.                std::cout<< str<<" from a static library\n";

14.              } 

15.              void sayString(void); 

16.  };

 

下面是文件 say.cpp是我们要加入到静态库中的两个对象文件之一的源码。它包含 Say类中sayString()函数的定义体；类 Say的一个实例 librarysay的声明也包含在内：

 

点击(此处)折叠或打开

1.    /* say.cpp */ 

2.    #include"say.h" 

3.    voidSay::sayString()

4.    {

5.                std::cout<<string<< "\n"; 

6.    }

7.    Saylibrarysay("Libraryinstance of Say");

 

源码文件 sayhello.cpp是我们要加入到静态库中的第二个对象文件的源码。它包含函数 sayhello()的定义：

 

1.    /*sayhello.cpp */ 

2.    #include"say.h" 

3.    voidsayhello() 

4.    { 

5.                std::cout<<"hellofrom a static library\n"; 

6.    }

 

下面的命令序列将源码文件编译成对象文件，命令 ar将其存进库中：$ g++ -c sayhello.cpp $ g++ -c say.cpp $ ar -r libsay.a sayhello.o say.o

程序 ar 配合参数 -r 创建一个新库libsay.a 并将命令行中列出的对象文件插入。采用这种方法，如果库不存在的话，参数 -r 将创建一个新的库，而如果库存在的话，将用新的模块替换原来的模块。

下面是主程序 saymain.cpp，它调用库 libsay.a中的代码：

 

点击(此处)折叠或打开

1.    /*saymain.cpp */ 

2.    #include"say.h" 

3.    int main(int argc,char*argv[]) 

4.    { 

5.                extern Say librarysay; 

6.               Saylocalsay = Say("Local instance of Say"); 

7.                sayhello(); librarysay.sayThis("howdy"); 

8.                librarysay.sayString();

9.                localsay.sayString(); 

10.              return(0); 

11.  }

 

该程序可以下面的命令来编译和链接：

$ g++ saymain.cpp libsay.a -o saymain

程序运行时，产生以下输出：

hello from a static library howdy from a static libraryLibrary instance of Say Local instance of Say

 

C与C++混合编程

C++ 是在 C 语言的基础上发展起来的。在某种程度上，我们可将 C++ 看做 C 的一种扩展。在本质上，二者的数据类型和函数调用惯例都是一致的，因此 C 与 C++ 混合编译也是很自然的事情。

二者的区别仅在于编译后函数的名字不同──C 简单地使用函数名而不考虑参数的个数或类型，而 C++ 编译后的函数名则总是将参数类型列表作为其一部分。尽管如此，C++ 提供了特殊的机制来声明 C 函数，这意味着一个 C++ 程序可以直接声明和调用 C 函数。

[编辑]C++调用C函数

下面是 C++ 程序调用 C 函数csayhello() 的一个例子。由于该函数在 C++ 程序内声明时使用了 extern "C"，故调用可以直接进行：

1.    /* cpp2c.cpp */ 

2.    #include<iostream> 

3.    extern"C" void csayhello(char*str); 

4.    int main(int argc,char*argv[]) 

5.    { 

6.                csayhello("Hello from cppto c"); 

7.                return(0); 

8.    }

 

C 函数不需任何特殊处理，其代码如下：

 

点击(此处)折叠或打开

1.    /* csayhello.c */ 

2.    #include<stdio.h> 

3.    voidcsayhello(char*str) 

4.    { 

5.                printf("%s\n",str); 

6.    }

 

下面三条命令编译以上两个文件并将二者链接为一个可执行文件。由于 gcc 和 g++ 的灵活性使得存在很多方法来完成该任务，但这三条命令或许是最常用的：

$ g++ -c cpp2c.cpp -o cpp2c.o

$ gcc -c csayhello.c -o csayhello.o 

$ gcc cpp2c.o csayhello.o -lstdc++ -o cpp2c

注意到，在最后链接的时候指定 C++ 标准库是必须的，这是因为我们用的是 gcc 而不是 g++ 调用的链接器。如果使用的是 g++ 的话，C++ 标准库默认会被链接。

最普遍的做法是，将函数声明放到头文件中，然后将所有内容包含在 extern "C" 声明块内。文件内容像下面所示：

 

1.    extern"C"{

2.    intmlimitav(intlowend,inthighend); 

3.    voidupdatedesc(char*newdesc); 

4.    doublegetpct(char*name); 

5.    };

 

[编辑]C调用C++函数

要使 C 程序能够调用 C++ 中函数的话，C++ 提供一个符合 C 调用惯例的函数是必须的。下面的例子演示了在 C++ 内创建 C 函数的语法：

1.    /*cppsayhello.cpp */

2.    #include<iostream> 

3.    extern"C" void cppsayhello(char*str);

4.    voidcppsayhello(char*str) 

5.    { 

6.                std::cout<< str<<"\n"; 

7.    }

尽管函数cppsayhello() 通过extern "C" 声明为 C 函数，事实上它是 C++ 源代码的一部分，这意味着函数体内是真正的 C++ 代码。在函数内你可以自由地创建和析构对象。如果你要在cppsayhello() 内调用 C 函数的话，将其声明为extern "C" 是必须的。否则，编译器会将作为一个 C++ 函数并相应地更改函数名。

下面是调用 C++ 函数cppsayhello() 的 C 程序：

1.    /* c2cpp.c */

2.    int main(int argc,char*argv[]) { 

3.                cppsayhello("Hello from C toC++"); 

4.                return(0); 

5.    }

下面的命令编译并链接生成c2cpp：

$ g++ -c cppsayhello.cpp -o cppsayhello.o 

$ gcc -c c2cpp.c -o c2cpp.o 

$ gcc cppsayhello.o c2cpp.o -lstdc++ -o c2cpp

(function(w, d, g, J) { var e = J.stringify || J.encode;d[g] = d[g] || {}; d[g]['showValidImages'] = d[g]['showValidImages'] ||function() { w.postMessage(e({'msg': {'g': g, 'm':'s'}}), location.href); }})(window, document, '__huaban', JSON);