https://www.cnblogs.com/battlescars/p/cpp_linux_gcc.html

linux下使用g++编译cpp工程

 

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

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

下面是一个保存在文件 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，向标准输出写入一个简单的字符串。该代码可用以下命令编译为可执行文件：

1 $ g++ helloworld.cpp

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

1 $ ./a.out
2 
3 hello, world

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

1 $ g++ helloworld.cpp -o helloworld

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

1 $ ./helloworld
2 
3 hello, world

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

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

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

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

1 $ c++ helloworld.cpp -o helloworld

2.多个源文件生成可执行程序

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

1 /* speak.h */
2 #include <iostream>
3 class Speak
4 {
5     public:
6         void sayHello(const char *);
7 };

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

1 /* speak.cpp */
2 #include "speak.h"
3 void Speak::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 }

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

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

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

3.源文件生成对象文件

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

1 $ g++ -c hellospeak.cpp

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

1 $ g++ -c hellospeak.cpp
2 
3 $ g++ -c speak.cpp
4 
5 $ g++ hellospeak.o speak.o -o hellospeak

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

1 $ g++ -c hellospeak.cpp -o hspk1.o
2 
3 $ g++ -c speak.cpp -o hspk2.o
4 
5 $ g++ hspk1.o hspk2.o -o hellospeak

4.编译预处理

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

1 $ g++ -E helloworld.cpp

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

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

1 $ gcc -E helloworld.cpp -o helloworld.ii

5.生成汇编代码

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

1 $ g++ -S helloworld.cpp

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

6.创建静态库

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

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

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

 1 /* say.h */
 2 #include <iostream>
 3 void sayhello(void);
 4 class Say {
 5     private:
 6         char *string;
 7     public:
 8         Say(char *str)
 9         {
10             string = str;
11         }
12         void sayThis(const char *str)
13         {
14             std::cout << str << " from a static library\n";
15         }
16         void sayString(void);
17 };

 

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

1 /* say.cpp */
2 #include "say.h"
3 void Say::sayString()
4 {
5     std::cout << string << "\n";
6 }
7 
8 Say librarysay("Library instance of Say");

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

1 /* sayhello.cpp */
2 #include "say.h"
3 void sayhello()
4 {
5     std::cout << "hello from a static library\n";
6 }

下面的命令序列将源码文件编译成对象文件，命令 ar 将其存进库中：

1 $ g++ -c sayhello.cpp
2 
3 $ g++ -c say.cpp
4 
5 $ 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     Say localsay = Say("Local instance of Say");
 7     sayhello();
 8     librarysay.sayThis("howdy");
 9     librarysay.sayString();
10     localsay.sayString();
11     return(0);
12 }

 

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

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

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

hello from a static library

howdy from a static library

Library instance of Say

Local instance of Say

原文地址：http://wiki.ubuntu.org.cn/Compiling_Cpp

菜鸟程序员，博客只做记录，可能问题很多，有问题，还望不吝指出！转载请附上原文地址，谢谢！

分类: cpp_linux

 

 

https://www.cnblogs.com/arxive/p/5072681.html

【转】C与CPP后缀的文件在编译时的区别

                                                     

  本文出处连接， by Ray FAN(ielnaf@qq.com)

                                                                 

    今天又发现了我的一个“不良习惯”，C语言的源文件用C还是CPP做后缀完全视心情而定，今天我就尝到苦头了，工程总是编不过去，准确的说是链接错误，后来发现工程下的文件多是c后缀的，只有一个是cpp后缀的，就把cpp后缀的改成了c后缀，编译、链接，OK了。

    在Google上搜索了一圈，发现就这一问题的文章比较少，也不是很系统，所以有了此篇小文，也是为了加深我的印象。

 

            结论：
            1.gcc认为.c的为C程序，.cpp的为C++程序；
            2.g++认为.c的为C++程序，.cpp的为C++程序；
            3.VC++的编译器cl认为.c的为C程序，.cpp的为C++程序；
            4.C程序与C++程序中同样的函数在编译后的obj文件中的symbol是不同的，所以以C方式编译的obj文件与以C++方式编译的obj文件无法成功链接。

 

            使个demo说明一下：
            准备工作：
            为gcc、g++、cl(VC++编译器)、link(VC++链接器)设置好环境变量
            //demo.cpp
            #include 
            #include "foo.h"
            int main()

            { 

                printHello(); 

                return 0;

            }

 

            //foo.h
            void printHello();

 

            //foo.c
            #include 
            void printHello()

            {

                printf("Hello MM");

            }

 

            1.gcc、g++测试，在windows的cmd下：
            D:\>g++ demo.cpp -o demo.obj -c （以C++方式编译生成demo.obj文件，-c选项表示只编译不链接）
            D:\>gcc foo.c -o foo.obj -c （以C方式编译生成foo.obj文件）
            D:\>g++ demo.obj foo.obj -o demo （链接demo.obj、foo.obj文件）
            demo.obj(.text+0x2b):demo.cpp: undefined reference to `printHello()'
            collect2: ld returned 1 exit status
                 提示说找不到printHello，因为按照C++的编译方式去找printHello应该对应某一种格式的symbol，但是我们

            的foo.obj中printHello的symbol是另外一种格式的，所以找不到了。
            把foo.c改成foo.cpp就可以成功链接了。

 

            2.cl、link测试，在windows的cmd下：
            D:\>cl demo.cpp /c （以C++方式编译生成demo.obj文件，/c选项表示只编译不链接）
            D:\>cl foo.c /c （以C方式编译生成foo.obj文件）
            D:\>link demo.obj foo.obj
            Microsoft (R) Incremental Linker Version 6.00.8168
            Copyright (C) Microsoft Corp 1992-1998. All rights reserved.

            demo.obj : error LNK2001: unresolved external symbol "void __cdecl printHello(void)"(?printHello@@YAXXZ)
            demo.exe : fatal error LNK1120: 1 unresolved externals
            理由同上，把foo.c改成foo.cpp就可以成功链接了。

 

 

 

            参考文章：
            1.gcc和g++的区别（开源CEO）
               http://www.linuxdiyf.com/bbs/viewthread.php?tid=109684
            2.在 console mode 中使用 C/C++ 编译器（jjhou候俊杰）
               http://jjhou.csdn.net/article99-10.htm

 

https://blog.csdn.net/zk3326312/article/details/78965647

一个CPP文件的编译过程
笼统的说一个CPP文件的编译过程就是以下几步

预处理(做优化，生成.i文件)
编译器(生成.s文件)
汇编器(生成.o文件)
链接器(连接库文件和其他目标代码)
生成可执行文件
c++为了兼容c程序，没有选择像java或者python之类的import当前源文件所用到的库，而是以include头文件的方式来将库的借口声明以文本替换的方式载入，然后重新解析，一个简单的helloworld程序，预处理的时候会读入将近20个头文件，预处理之后供编译器parse的源码有上万行。

g++ -E testHello.cpp -o testHello.i
1

c++预处理阶段主要完成的工作：处理#开始的预编译指令： 
（1）宏定义(#define)：对程序中所有出现的宏名，都用宏定义中的字符串去代换 
（2）文件包含(#include)：文件包含命令把指定头文件插入该命令行位置取代该命令行，从而把指定的文件和当前的源程序文件连成一个源文件。 
（3）条件编译(#ifdef)：一般情况下，源程序中所有的行都参加编译。但有时希望对其中一部分内容只在满足一定条件才进行编译，也就是对一部分内容指定编译的条件，这就是“条件编译”。有时，希望当满足某条件时对一组语句进行编译，而当条件不满足时则编译另一组语句。条件编译功能可按不同的条件去编译不同的程序部分，从而产生不同的目标代码文件。这对于程序的移植和调试是很有用的。

汇编阶段直接生成了汇编代码，具体过程不用赘述

链接器阶段则非常复杂，这里只简要叙述下主要的任务 
（1）函数重载：c++编译器为实现函数重载普遍使用的是名字改编的方式为每个函数生成一个独一无二的名字，链接的时候就能找到正确的重载版本 
（2）inline函数：如果函数体不太大，对此函数的所有调用都以函数本体去替代，注意inline只是对编译器的一个建议申请，不是强制命令 
（3）模板处理：函数定义（包括具现化后的函数模板，类模板的成员函数），变量定义（包括函数模板的静态数据变量，类模板的静态数据变量，类模板的全局对象等） 
（4）虚函数：每一个多态class都有一份虚函数表，定义或继承了虚函数的对象会有一个隐含成员：指向虚表的指针vptr，在构造或析构对象的时候，编译器生成的代码会修改这个指针。按道理说，一个多态class的虚表应该恰好被一个目标文件定义，这样链接就不会有错，但c++编译器有时无法判断是否应该在当前编译单元生成虚表定义，为保险起见，只能每个编译单元都生成虚表，然后交给链接器来消除重复数据。

c++使用的也是c语言的单遍编译的方式，意思就是从头到尾扫描一遍源码，一边解析源码，一边即刻生成目标代码，这么做的原因是：编译器没办法在内存里完整的表示单个源文件的抽象语法树，更不可能把整个程序（由多个源文件组成）放进内存里，以完成交叉引用（不同源文件的函数相互调用，使用外部变量等）
--------------------- 
作者：曾柯 
来源：CSDN 
原文：https://blog.csdn.net/zk3326312/article/details/78965647 
版权声明：本文为博主原创文章，转载请附上博文链接！

 

玩c++建议去linux下玩，首先要搞明白编译的是使用哪个编译器，编译的过程是怎么样。写写几个Makefile就知道了。先直接用命令行操作，然后用集成的IDE来写代码。
对于编译过程，总体上是这样，源代码（*.h,*.cpp/c）经过预编译，编译，生成目标文件（Windows下应该是.obj文件，Linux/unix下是.o文件），然后通过链接(将各种目标文件.obj(.o) 和 目标文件的集合(动态静态库dll(windows下)，so(linux/unix下)))，最终成功可执行文件（Windows下叫exe,Linux/unix下随便以什么结尾了）。

*.obj,*.pch,*.dsp,*.ncb,*.plg 这些，除了obj，其他都是微软集成的编译器做的事情了，微软其实也有个类似makefile的东西，其实你可以不用去关注的。这些C++本身无关。

 

 

c++程序在编译后,在目标路径下会生成多个文件：
Debug文件夹(*.exe,*.ilk,*.obj,*.pch,*.pdb,*.idb,*,pdb),*.cpp,*.dsp,*.ncb,*.plg
*.exe:是生成的可执行文件
*.ilk:当选定渐增型编译连接时，连接器自动生成ILK文件，记录连接信息
*.obj:是目标文件,源程序编译后的产物
*.pch:全称是PreCompiled Header，就是预先编译好的头文件
*.idb:文件保存的信息,使编译器在重新编译的时候只重编译最新改动过的函数和只对最新类定义改动过的源文件进行重编译，以提高编译速度
*.pdb:全称是Program DataBase，即程序数据库文件，用来记录调试信息
*.dsp:(全称是Developer Studio Project)也是一个配置文件
*.ncb:(全称No Compile Browser)的缩写，其中存放了供ClassView、WizardBar和Component Gallery使用的信息，由VC开发环境自动生成
*.plg:实际上是一个超文本文件，可以用Internet Explorer打开，记录了Build的过程
*.cpp:就是C++源代码文件.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

在编译源文件时，C编译器和C++编译器都会对符号(函数或变量)名作某些修正，但两者采用的修正方法不同，所以两者生成的目标文件不能互相链接。
     在C++中使用extern "C"可以让C++符号获得C链接特性。由于C++编译器会自动定义__cplusplus宏，所以在C语言头文件中采用这种结构可以保证无论使用何种编译器，生成的目标文件都具有C链接特性，能够与标准C编译器所生成的目标文件相链接。通常c/c++编译器会根据文件后缀来选择符号修正，所以最好把c的代码放到.c文件中，把c++的代码放到.cpp文件中。
     用VC++6.0创建动态库
     在test.cpp中输出c函数，如下：
           1、新建Win32 Dynamic-Link Library
           2、输出函数extern "C" _declspec(dllexport) void far test(); void far test(){ }
    而在test.c中输出c函数，就可以这样，如下：
           1、新建Win32 Dynamic-Link Library
           2、输出函数_declspec(dllexport) ...