Linux C/C++学习1：GCC使用初探

最新推荐文章于 2021-05-13 19:35:45 发布
最新推荐文章于 2021-05-13 19:35:45 发布
阅读量346 收藏 3
点赞数
分类专栏： Linux C/C++ 文章标签： linux c语言 c++ gcc/gdb编译调试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42997255/article/details/114221581
版权

Linux C/C++学习1：GCC使用初探

1. GCC简介

GCC，即GNU Compiler Collection，GNU项目中符合ANSI C标准的编译系统，能够编译C、C++和Object C等语言编写的程序，是Linux下最常用的C语言编译器。使用GCC编译程序时，编译过程可以被细分为四个阶段：

  • 预处理（Pre-Processing）
  • 编译（Compiling）
  • 汇编（Assembling）
  • 链接（Linking）

Linux程序员可以根据自己的需要让GCC在编译过程的任何阶段结束，以便检查或使用GCC在该阶段的输出信息，或者对最后生成的二进制文件进行控制，以便通过加入不同数量和种类的调试代码来为今后的调试做好准备。

GCC也提供了灵活而强大的代码优化功能，可以生成执行效率更高的代码。GCC提供了30多条警告信息和3个警告级别，使用它们有助于增强程序的稳定性和可移植性。此外，GCC还对标准的C和C++语言进行了大量的扩展，提高程序的执行效率，有助于编译器进行代码优化，能够减轻编程的工作量。

2. GCC编译过程

这里通过一个简单的实例，了解一下GCC的编译过程，实例代码如下：

// File：hello.c
#include <stdio.h>
int main(void)
{
	printf("Hello Linux C!\n");
	return 1;
}

执行gcc hello.c -o hello，运行结果如下。从程序员的角度看，只需简单地执行一条GCC命令就可以了。但从编译器的角度来看，却需要完成一系列非常繁杂的工作：

  1. 首先，GCC调用预处理程序cpp，展开在源文件中定义的宏，并向其中插入#include语句所包含的内容；
  2. 接着，GCC调用ccl和as，将处理后的源代码编译成目标代码；
  3. 最后，GCC调用链接程序ld，把生成的目标代码链接成一个可执行程序。
root@ubuntu:/opt# gcc hello.c -o hello
root@ubuntu:/opt# ./hello 
Hello Linux C!
root@ubuntu:/opt#

为了更好地理解GCC的工作过程，可以把上述编译过程分成几个步骤单独进行，并观察每步的运行结果。

  1. 预处理，执行gcc -E hello.c -o hello.i，使用-E参数可以让GCC在预处理结束后停止编译过程.。此时若查看hello.i文件，会发现stdio.h的内容都插到里面去了，而其它应当被预处理的宏定义也都做了相应的处理。
root@ubuntu:/opt# gcc -E hello.c -o hello.i
root@ubuntu:/opt# ls
hello.c  hello.i
  1. 编译，执行gcc -c hello.i -o hello.o，使用-c参数将hello.i编译成目标代码。GCC默认将.i文件看成是预处理后的C语言源代码，因此上述命令将自动跳过预处理步骤而开始执行编译过程，也可以使用-x参数让GCC从指定的步骤开始编译。
root@ubuntu:/opt# gcc -c hello.i -o hello.o
root@ubuntu:/opt# ls
hello.c  hello.i  hello.o
root@ubuntu:/opt#
  1. 链接，执行gcc hello.o -o hello，将生成的.o目标文件链接成可执行文件。
root@ubuntu:/opt# gcc hello.o -o hello
root@ubuntu:/opt# ls
hello  hello.c  hello.i  hello.o
root@ubuntu:/opt#

在采用模块化的设计思想进行软件开发时，通常整个程序是由多个源文件组成的，相应地也就形成了多个编译单元，使用GCC能够很好地管理这些编译单元。

假设有一个由foo1.c和foo2.c两个源文件组成的程序，为了对它们进行编译，并最终生成可执行程序foo，可以使用下面这条命令：
gcc foo1.c foo2.c -o foo

如果同时处理的文件不止一个，GCC仍然会按照预处理、编译和链接的过程依次进行。如果深究起来，上面这条命令大致相当于依次执行如下三条命令：
gcc -c foo1.c -o foo1.o
gcc -c foo2.c -o foo2.o
gcc foo1.o foo2.o -o foo

在编译一个包含许多源文件的工程时，若只用一条GCC命令来完成编译是非常浪费时间的。假设项目中有100个源文件需要编译，并且每个源文件中都包含10000行代码。如果像上面那样仅用一条GCC命令来完成编译工作，那么GCC需要将每个源文件都重新编译一遍，然后再全部链接起来。很显然，这样浪费的时间相当多，尤其是当用户只是修改了其中某一个文件的时候，完全没有必要将每个文件都重新编译一遍，因为很多已经生成的目标文件是不会改变的。要解决这个问题，关键是要灵活运用GCC，同时还要借助类似Make这样的工具。

3. GCC告警提示

GCC包含完整的出错检查和警告提示功能，可以帮助Linux程序员写出更加专业和优美的代码。下面是一段有语法错误的实例代码，看看GCC在编译时如何提示错误信息。

// File: illcode.c
#include <stdio.h>
int main(void)
{
	int var_int = 1;
	printf("It is not standard C code!\n");
	return 0
}
  • 执行 gcc -pedantic illcode.c -o illcode
    当GCC在编译不符合ANSI/ISO C语言标准的源代码时，如果加上了-pedantic选项，那么使用了扩展语法的地方将产生相应的警告信息。需要注意的是，-pedantic并不能保证被编译程序与ANSI/ISO C标准的完全兼容，它仅仅只能用来帮助程序员离这个目标越来越近。或者换句话说，-pedantic选项能够帮助程序员发现一些不符合 ANSI/ISO C标准的代码，但不是全部。事实上只有ANSI/ISO C语言标准中要求进行编译器诊断的那些情况，才有可能被GCC发现并提出警告。
root@ubuntu:/opt# gcc -pedantic illcode.c -o illcode
illcode.c: In function ‘main’:
illcode.c:8:1: error: expected ‘;’ before ‘}’ token
 }
 ^
root@ubuntu:/opt#
  • 执行gcc -Wall illcode.c -o illcode
    除了-pedantic之外，GCC还有一些其它编译选项也能够产生有用的警告信息。这些选项大多以-W开头，其中最有价值的便是-Wall，它能够使GCC产生尽可能多的警告信息。
    另外，GCC给出的警告信息虽然从严格意义上说不能算作是错误，但却很可能成为错误的栖身之所。一个优秀的Linux程序员应该尽量避免产生警告信息，使自己的代码始终保持简洁、优美和健壮的特性。
root@ubuntu:/opt# gcc -Wall illcode.c -o illcode
illcode.c: In function ‘main’:
illcode.c:8:1: error: expected ‘;’ before ‘}’ token
 }
 ^
illcode.c:5:6: warning: unused variable ‘var_int’ [-Wunused-variable]
  int var_int = 1;
      ^~~~~~~
root@ubuntu:/opt#
  • 执行gcc -Wall -Werror illcode.c -o illcode
    在处理警告方面，另一个常用的编译选项是-Werror，它要求GCC将所有的警告当成错误进行处理，这在使用自动编译工具（如Make等）时非常有用。如果编译时带上-Werror选项，那么GCC会在所有产生警告的地方停止编译，迫使程序员对自己的代码进行修改。只有当相应的警告信息消除时，才可能将编译过程继续推进。
root@ubuntu:/opt# gcc -Wall -Werror illcode.c -o illcode
illcode.c: In function ‘main’:
illcode.c:8:1: error: expected ‘;’ before ‘}’ token
 }
 ^
illcode.c:5:6: error: unused variable ‘var_int’ [-Werror=unused-variable]
  int var_int = 1;
      ^~~~~~~
cc1: all warnings being treated as errors
root@ubuntu:/opt#

对Linux程序员来讲，GCC给出的警告信息是很有价值的，它们不仅可以帮助程序员写出更加健壮的程序，而且还是跟踪和调试程序的有力工具。建议在用GCC编译源代码时始终带上-Wall选项，并把它逐渐培养成为一种习惯，这对找出常见的隐式编程错误很有帮助。

4. GCC库依赖

在Linux下开发软件时，完全不使用第三方函数库的情况是比较少见的，通常来讲都需要借助一个或多个函数库的支持才能够完成相应的功能。从程序员的角度看，函数库实际上就是一些头文件（.h）和库文件（.so或者.a）的集合。虽然Linux下的大多数函数都默认将头文件放到/usr/include/目录下，而库文件则放到/usr/lib/目录下，但并不是所有的情况都是这样。正因如此，GCC在编译时必须有自己的办法来查找所需要的头文件和库文件。GCC采用搜索目录的办法来查找所需要的文件：

  • 示例1：gcc foo.c -I /home/carlos/include -o foo
    其中，-I选项可以向GCC的头文件搜索路径中添加新的目录。如示例1所示，如果在/home/carlos/include目录下有编译时所需要的头文件，为了让GCC能够顺利地找到它们，就可以使用-I选项。
  • 示例2：gcc foo.c -L /home/carlos/lib -lfoo -o foo
    如果使用了不在标准位置的库文件，那么可以通过-L选项向GCC的库文件搜索路径中添加新的目录。如示例2所示，如果在/home/carlos/lib目录下有链接时所需要的库文件libfoo.so，为了让GCC能够顺利地找到它，可以使用-L选项。
    值得好好解释一下的是-l选项，它指示GCC去连接库文件libfoo.so。Linux下的库文件在命名时有一个约定，即应该以lib三个字母开头，由于所有的库文件都遵循了同样的规范，因此在用-l选项指定链接的库文件名时可以省去lib三个字母。也就是说GCC在对-lfoo进行处理时，会自动去链接名为libfoo.so的文件。
  • 示例3：gcc foo.c -L /home/carlos/lib -static -lfoo -o foo
    Linux下的库文件分为两大类，分别是动态链接库（通常以.so结尾）和静态链接库（通常以.a结尾）。两者的差别仅在于程序执行时所需的代码是在运行时动态加载的，还是在编译时静态加载的。默认情况下，GCC在链接时优先使用动态链接库，只有当动态链接库不存在时才考虑使用静态链接库。如果需要的话可以在编译时加上-static选项，强制使用静态链接库。如示例3所示，如果在/home/carlos/lib目录下有链接时所需要的库文件libfoo.so和libfoo.a，为了让GCC在链接时只用到静态链接库，可以使用-static选项。

5. GCC代码优化

代码优化指的是编译器通过分析源代码，找出其中尚未达到最优的部分，然后对其重新进行组合，目的是改善程序的执行性能。

GCC提供的代码优化功能非常强大，它通过编译选项-On来控制优化代码的生成，其中n是一个代表优化级别的整数。对于不同版本的GCC来讲，n的取值范围及其对应的优化效果可能并不完全相同，比较典型的范围是从0变化到2或3。

  • 选项-O可以告诉GCC同时减小代码的长度和执行时间，其效果等价于-O1；在这一级别上能够进行的优化类型虽然取决于目标处理器，但一般都会包括线程跳转（Thread Jump）和延迟退栈（Deferred Stack Pops）两种优化；
  • 选项-O2告诉GCC除了完成所有-O1级别的优化之外，同时还要进行一些额外的调整工作，如处理器指令调度等；
  • 选项-O3除了完成所有-O2级别的优化之外，还包括循环展开和其它一些与处理器特性相关的优化工作。

通常来说，n越大优化的等级越高，同时也就意味着程序的运行速度越快。许多Linux程序员都喜欢使用-O2选项，因为它在优化长度、编译时间和代码大小之间，取得了一个比较理想的平衡点。

下面通过具体实例来感受一下GCC的代码优化功能，实例代码如下：

// File: optimize.c
#include <stdio.h>
int main(void)
{
	double counter;
	double result;
	double temp;
	for (counter = 0; counter < 2000.0*2000.0*2000.0/20.0+2020; counter += (5-1)/4) 
	{
		temp = counter / 1979;
		result = counter;   
	}
	printf("Result is %lf\n", result);
	return 0;
}
  • 使用gcc -Wall optimize.c -o optimize编译（不加优化），time结果
root@ubuntu:/opt# time ./optimize
Result is 400002019.000000

real	0m1.418s
user	0m1.417s
sys	0m0.000s
root@ubuntu:/opt#
  • 使用gcc -Wall -O optimize.c -o optimize编译（加优化），time结果
root@ubuntu:/opt# time ./optimize
Result is 400002019.000000

real	0m0.625s
user	0m0.620s
sys	0m0.004s
root@ubuntu:/opt#

对比两次执行的输出结果不难看出，程序性能的确得到了很大幅度的改善。

尽管GCC的代码优化功能非常强大，但作为一名优秀的Linux程序员，首先还是要力求能够手工编写出高质量的代码。如果编写的代码简短，并且逻辑性强，编译器就不会做更多的工作，甚至根本用不着优化。

另外，优化虽然能够给程序带来更好的执行性能，但在如下一些场合中应该避免优化代码：

  • 程序开发的时候：优化等级越高，消耗在编译上的时间就越长；因此在开发的时候最好不要使用优化选项，只有到软件发行或开发结束的时候，才考虑对最终生成的代码进行优化；
  • 资源受限的时候：一些优化选项会增加可执行代码的体积，如果程序在运行时能够申请到的内存资源非常紧张（如一些实时嵌入式设备），那就不要对代码进行优化，因为由此带来的负面影响可能会产生非常严重的后果；
  • 跟踪调试的时候：在对代码进行优化的时候，某些代码可能会被删除或改写，或者为了取得更佳的性能而进行重组，从而使跟踪和调试变得异常困难。

6. GCC调试符号

一个功能强大的调试器不仅为程序员提供了跟踪程序执行的手段，而且还可以帮助程序员找到解决问题的方法。对于Linux程序员来讲，GDB（GNU Debugger）通过与GCC的配合使用，为基于Linux的软件开发提供了一个完善的调试环境。

默认情况下，GCC在编译时不会将调试符号插入到生成的二进制代码中，因为这样会增加可执行文件的大小。如果需要在编译时生成调试符号信息，可以使用GCC的-g或者-ggdb选项。GCC在产生调试符号时，同样采用了分级的思路，开发人员可以通过在-g选项后附加数字1、2或3来指定在代码中加入调试信息的多少。

  • 级别2（-g2，默认级别），此时产生的调试信息包括扩展的符号表、行号、局部或外部变量信息；
  • 级别3（-g3），包含级别2中的所有调试信息，以及源代码中定义的宏；
  • 级别1（-g1），不包含局部变量和与行号有关的调试信息，因此只能够用于回溯跟踪和堆栈转储之用。回溯跟踪指的是监视程序在运行过程中的函数调用历史，堆栈转储则是一种以原始的十六进制格式保存程序执行环境的方法，两者都是经常用到的调试手段。

GCC产生的调试符号具有普遍的适应性，可以被许多调试器加以利用。但如果使用的是GDB，那么还可以通过-ggdb选项在生成的二进制代码中包含GDB专用的调试信息。这种做法的优点是可以方便GDB的调试工作，但缺点是可能导致其它调试器（如DBX）无法进行正常的调试。选项-ggdb能够接受的调试级别和-g是完全一样的，它们对输出的调试符号有着相同的影响。

需要注意的是，使用任何一个调试选项都会使最终生成的二进制文件的大小急剧增加，同时增加程序在执行时的开销，因此调试选项通常仅在软件的开发和调试阶段使用。调试选项对生成代码大小的影响从下面的optimize.c编译对比过程中便可以看出来。

root@ubuntu:/opt# gcc optimize.c -o optimize
root@ubuntu:/opt# ls optimize -l
-rwxr-xr-x 1 root root 8304 Feb 28 01:53 optimize
root@ubuntu:/opt# 
root@ubuntu:/opt# gcc -g optimize.c -o optimize
root@ubuntu:/opt# ls optimize -l
-rwxr-xr-x 1 root root 10848 Feb 28 01:54 optimize
root@ubuntu:/opt#

虽然调试选项会增加文件的大小，但事实上Linux中的许多软件在测试版本甚至最终发行版本中仍然使用了调试选项来进行编译，这样做的目的是鼓励用户在发现问题时自己动手解决，是Linux的一个显著特色。

接下来，通过一个具体的实例说明如何利用调试符号来分析错误，实例代码如下：

// File: crash.c
#include <stdio.h>
int main(void)
{
	int input = 0;
	printf("Input an integer:");
	scanf("%d", input);
	printf("The integer you input is %d\n", input);
	return 0;
}
  1. 编译并运行上述代码，会产生一个严重的段错误（Segmentation fault），如下：
root@ubuntu:/opt# gcc -g crash.c -o crash
crash.c: In function ‘main’:
crash.c:7:10: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type ‘int’ [-Wformat=]
  scanf("%d", input);
         ~^
root@ubuntu:/opt# 
root@ubuntu:/opt# ./crash 
Input an integer:10
Segmentation fault (core dumped)
root@ubuntu:/opt#
  1. 为了更快速地发现错误所在，可以使用GDB进行跟踪调试，过程如下：
  • 执行gdb crash，当GDB提示符出现的时候，表明GDB已经做好准备进行调试了。
root@ubuntu:/opt# gdb crash
GNU gdb (Ubuntu 8.1-0ubuntu3.2) 8.1.0.20180409-git
Copyright (C) 2018 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from crash...done.
(gdb)
  • 现在可以通过run命令让程序开始在GDB的监控下运行。仔细分析一下GDB给出的输出结果不难看出，程序是由于段错误而导致异常中止的，说明内存操作出了问题，具体发生问题的地方是在调用_IO_vfscanf_internal的时候。
(gdb) run
Starting program: /opt/crash 
Input an integer:10

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff7a53932 in _IO_vfscanf_internal (s=<optimized out>, format=<optimized out>, argptr=argptr@entry=0x7fffffffde30, errp=errp@entry=0x0)
    at vfscanf.c:1898
1898	vfscanf.c: No such file or directory.
(gdb)
  • 为了得到更加有价值的信息，可以使用GDB提供的回溯跟踪命令backtrace，执行结果如下。从输出结果的#2行中不难看出，GDB已经将错误定位到crash.c中的第7行了。
(gdb) backtrace
#0  0x00007ffff7a53932 in _IO_vfscanf_internal (s=<optimized out>, format=<optimized out>, argptr=argptr@entry=0x7fffffffde30, 
    errp=errp@entry=0x0) at vfscanf.c:1898
#1  0x00007ffff7a60048 in __isoc99_scanf (format=<optimized out>) at isoc99_scanf.c:37
#2  0x00005555555546e0 in main () at crash.c:7
(gdb)
  • 使用GDB提供的frame命令可以定位到发生错误的代码段，该命令后面跟着的数值可以在backtrace命令输出结果中的行首找到。现在已经发现错误所在了，应该将input改成&input。
(gdb) frame 2
#2  0x00005555555546e0 in main () at crash.c:7
7		scanf("%d", input);
(gdb)
  • 完成后使用quit退出GDB。
(gdb) quit
A debugging session is active.

	Inferior 1 [process 18519] will be killed.

Quit anyway? (y or n) y
root@ubuntu:/opt#

GDB的功能远远不止如此，它还可以单步跟踪程序、检查内存变量和设置断点等等，不是本文讨论的重点。

另外，调试时可能会需要用到编译器产生的中间结果，这时可以使用-save-temps选项，让GCC将预处理代码、汇编代码和目标代码都作为文件保存起来。如果想检查生成的代码是否能够通过手工调整的办法来提高执行性能，在编译过程中生成的中间文件将会很有帮助，过程如下：

root@ubuntu:/opt/temp# ls
optimize.c
root@ubuntu:/opt/temp# gcc -save-temps optimize.c -o optimize
root@ubuntu:/opt/temp# ls
optimize  optimize.c  optimize.i  optimize.o  optimize.s
root@ubuntu:/opt/temp#

GCC支持的其它调试选项还包括-p和-pg，它们会将剖析（Profiling）信息加入到最终生成的二进制代码中。剖析信息对于找出程序的性能瓶颈很有帮助，是协助Linux程序员开发出高性能程序的有力工具。在编译时加入-p选项会在生成的代码中加入通用剖析工具（Prof）能够识别的统计信息，而-pg选项则生成只有GNU剖析工具（Gprof）才能识别的统计信息。

最后提醒一点，虽然GCC允许在优化的同时加入调试符号信息，但优化后的代码对于调试本身而言将是一个很大的挑战。代码在经过优化之后，在源程序中声明和使用的变量很可能不再使用，控制流也可能会突然跳转到意外的地方，循环语句有可能因为循环展开而变得到处都有，所有这些对调试来讲都将是一场噩梦。建议在调试的时候最好不使用任何优化选项，只有当程序在最终发行的时候才考虑对其进行优化。

7. GCC加速编译

源代码变成可执行文件的过程中，需要经过许多中间步骤，包含预处理、编译、汇编和链接。这些过程实际上是由不同的程序负责完成的。大多数情况下GCC可以为Linux程序员完成所有的后台工作，自动调用相应程序进行处理。

这样做有一个很明显的缺点，就是GCC在处理每一个源文件时，最终都需要生成好几个临时文件才能完成相应的工作，从而无形中导致处理速度变慢。例如，GCC在处理一个源文件时，可能需要一个临时文件来保存预处理的输出、一个临时文件来保存编译器的输出、一个临时文件来保存汇编器的输出，而读写这些临时文件显然需要耗费一定的时间。当软件项目变得非常庞大的时候，花费在这上面的代价可能会变得很沉重。

解决的办法是，使用Linux提供的一种更加高效的通信方式——管道。它可以用来同时连接两个程序，其中一个程序的输出将被直接作为另一个程序的输入，这样就可以避免使用临时文件，但编译时却需要消耗更多的内存。

在编译过程中使用管道是由GCC的-pipe选项决定的，例如gcc -pipe foo.c -o foo。在编译小型工程时使用管道，编译时间上的差异可能不是很明显，但在源代码非常多的大型工程中，差异将变得非常明显。

8. GCC常规事项说明

8.1 文件扩展名

在使用GCC的过程中，程序员对一些常用的扩展名一定要熟悉，并知道其含义，在此将这些扩展名列举如下：

扩展名说明
.cC原始程序
.CC++原始程序
.ccC++原始程序
.cxxC++原始程序
.mObjective-C原始程序
.i已经过预处理的C原始程序
.ii已经过预处理之C++原始程序
.s组合语言原始程序
.S组合语言原始程序
.h预处理文件（头文件）
.o目标文件
.a存档文件

8.2 GCC常用选项

GCC作为Linux下C/C++重要的编译环境，功能强大，编译选项繁多，在此将常用的选项及说明列举如下：

选项说明
-c通知GCC取消链接步骤，即编译源码并在最后生成目标文件
-Dmacro定义指定的宏，使它能够通过源码中的#ifdef进行检验
-E不经过编译预处理程序的输出而输送至标准输出
-g3获得有关调试程序的详细信息，它不能与-o选项联合使用
-Idirectory在包含文件搜索路径的起点处添加指定目录
-llibrary提示链接程序在创建最终可执行文件时包含指定的库
-O、-O2、-O3将优化状态打开，该选项不能与-g选项联合使用
-S要求编译程序生成来自源代码的汇编程序输出
-v启动所有警报
-Wall编译后显示所有警告
-Werror在发生警报时取消编译操作，即把报警当作是错误
-w禁止所有的报警

9. 总结说明

  1. 本文主要是对GCC使用详解博文的学习记录，以便加深印象；
  2. 此文档仅用于学习记录和交流，如能帮助到读者倍感荣幸。
回笼觉觉父
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux C 编程学习笔记1-GCC
未来路上，走走停停~
07-04 396
--写在前面-- 编程小白开启Linux C 学习之旅，整理Linux C 编程相关内容方便日后复习。本系列所记录内容是来自日常阅读博客或其他文章经过消化整理所得（具体参照不详）。 大家一起共同学习，若有不足之处，烦请指正。 ------------------------------------------------------------------------正文----------
Linux 段错误详解
feixiaku的专栏
04-06 3955
By Falcon ofTinyLab.org 2015/05/12 目录 1背景 2什么是段错误 3段错误日志分析 3.1例子 3.2段错误信息 3.3段错误分析 4常见段错误举例 4.1scanf 参数：把 &i 写为 i 4.2sprintf/printf 参数：%d/%c 写成 %s 4.3数组访问越界 4.4写只读内存 4.5
linux gcc scanf,在linux 64位上使用nasm + gcc时，scanf抛出了分段错误(核心转储)。
weixin_27010489的博客
05-13 214
3Use sub rsp, 8 / add rsp, 8 at the start/end of your function to re-align the stack to 16 bytes before your function does a call.在函数开始/结束时使用sub rsp, 8 / add rsp, 8在函数调用之前将堆栈重新对齐到16字节。Or better push/p...
GCC编译优化指南
cybertan的专栏
08-07 3584
CFLAGS 与 CXXFLAGS<br />CFLAGS 表示用于 C 编译器的选项，CXXFLAGS 表示用于 C++ 编译器的选项。这两个变量实际上涵盖了编译和汇编两个步骤。大多数程序和库在编译时默认的优化级别是"2"(使用"-O2"选项)并且带有调试符号来编 译，也就是 CFLAGS="-O2 -g", CXXFLAGS=$CFLAGS 。事实上，"-O2"已经启用绝大多数安全的优化选项了。另一方面，由于大部分选项可以同时用于这两个变量，所以仅在最后讲述只能用于其中一个变量的选 项。[提醒]
gcc 编译优化指南
jc_liuworld的专栏
12-07 934
CFLAGS 与 CXXFLAGS CFLAGS 表示用于 C 编译器的选项，CXXFLAGS 表示用于 C++ 编译器的选项。这两个变量实际上涵盖了编译和汇编两个步骤。大多数程序和库在编译时默认的优化级别是"2"(使用"-O2"选项)并且带有调试符号来编 译，也就是 CFLAGS="-O2 -g", CXXFLAGS=$CFLAGS 。事实上，"-O2"已经启用绝大多数安全的优化选项了。另
warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘time_t {aka long int}
热门推荐
workspace
04-02 3万+
Linux编程出错: 今天写时间编程,测试一个小程序 编译的时候却报错 错误分析:%d需要另一个类型的整数,应该是长整型或无符号 粘贴错误指令搜索,发现了解决办法☞ %md，m为指定的输出字段的宽度。如果数据的位数小于m，则左端补以空格，若大于m，则按实际位数输出。 %ld(%mld 也可)，输出长整型数据。 u格式符，用来输出unsigned型数据，无符号数，以十进制数形式...
cc1-放入/usr/libexec/gcc/x86_64-redhat-linux/4.4.4/内
06-30
gcc: error trying to exec 'cc1': execvp: No such file or directory
Eclipse IDE for C/C++ Linux64位
04-16
Eclipse IDE for C/C++ Linux64位是一款专为Linux平台设计的集成开发环境，针对C和C++编程语言提供了全面而强大的支持。Eclipse作为一个开源的、跨平台的开发工具，其C/C++版本是许多软件工程师和学生在Linux系统上...
ubuntu/kylin系统离线安装gcc-g++-c++
08-25
libcc1; libcilkrts5; libgcc-7; libgcc1; libgomp1; libisl1; libitm1; liblsan0_8.4.0-1; libmpc3_1.1.0-1_amd64.deb libmpfr6_4.0.1-1_amd64.deb libmpx2_8.4.0-1; libquadmath0_8.4.0-1; libstdc++-7-dev_7.5.0-...
Linux系统中如何编写C/C++程序
01-09
很多学习Linux系统的小伙伴都免不了要在Linux系统中进行C/C++程序的编写、编译与执行，下面就来谈谈如何进行C/C++的编程。 以下操作均在CentOS 7中执行，顺便提一句，如果你用的是RedHat系统的话，要果断放弃，换成...
Linux开发入门：使用gdb调试C/C++入门教程
06-22
在此我们仅涉及 C 和 C++ 的调试，而不包括其它语言。还有一点要说明的是，GDB是一个调试器，而不像 VC 是一个集成环境。你可以使用一些前端工具如XXGDB、DDD等。他们都有图形化界面，因此使用更方便，但它们仅是GDB...
服务器性能调优-菜鸟初尝试
wjj547670933的专栏
04-11 1873
有时间后台服务会遇到cpu消耗过高的问题，这个时候需要找出到代码中导致高消耗的函数调用，予以优化。下面举个最简单的例子。         1.发现目标进程cpu过于繁忙并且VIRT值过大。          VIRT过大是因为目标进程attach了一块很大的共享内存，所以不是问题。但是cpu消耗有点大，现在每分钟包量不足13W，那么大约30W就会把cpu撑满，而我们服务器通常每分钟可以处理
Linux基于流IO
刘森林l的博客
08-21 2288
 基于流的I/O操作        流的打开 函数：(1) FILE *fopen(const char *pathname,const char *type);         (2) FILE *freopen(const char *pathname,const char *type, FILE *fp);         (3) FILE *fdopen(int filede
scanf源码分析
chennbnbnb的博客
12-02 1160
本文分析的是glibc2.31中的scanf相关源码，目的不是研究scanf的算法，而是说明scanf在IO attack中的利用方法，属于CTF的范畴 scanf.c 其实就是对__vscanf_internal的封装 __scanf (const char *format, ...) { va_list arg; int done; va_start (arg, format); done = __vfscanf_internal (stdin, format, arg, 0)
gcc zz
小春的药匣子
08-29 1491
 防止gcc -O3 强制 inline一个函数  一个函数，如果代码量比较少的话，用 -O3优化开关的话，gcc有可能将这个函数强制内联(inline)即使，你在函数前没有写inline助记符。 如果是一个手写汇编的函数，那样的话很有可能破坏参数。gcc里有强制不内联的，用法如下void foo() __attribute__((noinline));但是有的gcc可能会忽略 n
［授权发表］Linux 段错误详解
05-21 3138
笔者早年写过一篇：《可恶的"Segmentation faults"之初级总结篇》，网络转载甚多。多年下来，关于段错误的讨论依旧很热烈，该问题也还是很常见。所以打算在这里再系统地梳理一下该问题的来龙去脉。
GCC编译器常识(转)
维纳斯的迷图
04-23 511
[GCC编译器常识(转)][1]编译器， GCC 在为Linux开发应用程序时，绝大多数情况下使用的都是C语言，因此几乎每一位Linux程序员面临的首要问题都是如何灵活运用C编译器。目前Linux下最常用的C语言编译器是GCC（GNU Compiler Collection），它是GNU项目中符合ANSI C标准的编译系统，能够编译用C、C++和Object C等语言编写的程序。GCC不仅功能非
Linux下C/C++编译器gcc使用简介
fbfsber008的专栏
10-24 458
1.gcc包含的c/c++编译器 gcc,cc与c++,g++ gcc和cc是一样的，c++和g++是一样的。一般c程序就用gcc编译，c++程序就用g++编译。 2.gcc的基本用法 gcc test.c：如果没有指定输出的文件，默认将编译出一个名为a.out的程序 gcc test.c -o test：-o参数用来指定生成目标程序的名字，这样将编译出一个名为test的程序。 3.为
-/bin/sh: gcc: not found
最新发布
02-23
gcc 是 GNU Compiler Collection 的缩写，是一种常用的编译器工具，用于编译 C、C++ 等程序语言。 如果你在使用 gcc 编译器时遇到了这个错误，可能是因为你的系统没有安装 gcc 或者没有将其路径添加到环境变量中。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值