详解编译+链接

gcc -E test.c -o test.i 、

gcc -S test.i -o test.s

gcc -c test.s -o test.o

详解编译+链接

gcc -E test.c -o test.i

gcc -S test.i -o test.s

gcc -c test.s -o test.o

总结编译+连接

预处理(a.头文件的展开，b.去注释，c宏替换，d条件编译)
编译(把C语言变成汇编语言)
汇编(通过汇编变成以.o结尾的目标二进制文件，二进制不可执行)-obj
连接(本质引入我们在代码中使用的第三方库)

注：推荐一本书《程序员的自我修养》

简明 Vim 练级攻略 | 酷壳 - CoolShell

给程序员的VIM速查卡 | 酷壳 - CoolShell

预处理详解

预定义符号

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	printf("%s\n", __FILE__);
	printf("%d\n", __LINE__);
	printf("%s\n", __DATE__);
	printf("%s\n", __TIME__);
	printf("%s\n", __FUNCTION__);

	int i = 0;
	FILE* pf = fopen("log.txt", "a+");
	if (pf == NULL)
	{
		perror("fopen\n");
		return 1;
	}
	for (i = 0; i < 10; i++)
	{
		fprintf(pf, "%s %d %s %s %d\n",\
			__FILE__, __LINE__, __DATE__, __TIME__, i);
	}
	fclose(pf);
	pf = NULL;

	//printf("%d\n", __STDC__);//不支持
	return 0;
}

这些预定义符号都是语言内置的。

#define 定义标识符

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define M 1000

int main()
{
	int a = 10;
	int b = 0;
	if (a > 10)
		b = M;
	else
		b = -M;

	return 0;
}

建议不要加上 ; ,这样容易导致问题

#define 定义宏

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define SQUARE(X) (X*X)

#define DOUBLE(X) ((X)+(X))

int main()
{
	printf("%d\n", SQUARE(3+1));
	printf("%d\n", 10 * DOUBLE(4));

	//printf("%d\n", 3 + 1 * 3 + 1);
	//printf("%d\n", 10 * ((4) + (4)));
	
	return 0;
}

注：在#define定义的宏中()是尤其重要的

#define 替换规则

宏参数和#define 定义中可以出现其他#define定义的变量。但是对于宏，不能出现递归。
当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

#和##

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define PRINT(X, FORMAT) printf("the value of "#X" is "FORMAT"\n", X);
int main()
{
	int a = 10;
	PRINT(a, "%d");
	//printf("the value of ""a"" is %d\n", a);

	float f = 5.5f;
	PRINT(f, "%f");
	//printf("the value of "f" is ""%f""\n", f);

	return 0;
}

# ，把一个宏参数变成对应的字符串。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define CAT(X,Y,Z) X##Y##Z
int main()
{
	int class101101 = 100;
	printf("%d\n", CAT(class, 101, 101));
	//printf("%d\n", class101101);

	return 0;
}

##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符。
注：这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

带副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
int Max(int x, int y)
{
	return x > y ? x : y;
}

int main()
{
	int a = 5;
	int b = 8;
	int m = MAX(a++, b++);
	//int m = ((a++) > (b++) ? (a++) : (b++));
	printf("a=%d b=%d\n", a, b);
	printf("m=%d\n", m);

	return 0;
}

宏和函数对比

宏通常被应用于执行简单的运算。比如在两个数中找出较大的一个。

那为什么不用函数来完成这个任务？

原因有二：

用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。
更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。宏是类型无关的。

当然和宏相比函数也有劣势的地方：

每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
宏是没法调试的(在预处理就完成的替换)
宏由于类型无关，也就不够严谨。
宏可能会带来运算符优先级的问题，导致程容易出现错。

宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define MALLOC(num, type) (type*)malloc(num*sizeof(type))

int main()
{
	//malloc(10*sizeof(int));
	int*p = MALLOC(10, int);

	//(int*)malloc(10 * sizeof(int));
	return 0;
}

宏和函数的一个对比

属性	#define定义宏	函数
代码长度	每次使用时，宏代码都会被插入到程序中。除了非常小的宏之外，程序的长度会大幅度增长	函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码
执行速度	更快	存在函数的调用和返回的额外开销，所以相对慢一些
操作符优级	宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多些括号。	函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测。
带有副作用的参数	参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果。	函数参数只在传参的时候求值一次，结果更容易控制。
参数类型	宏的参数与类型无关，只要对参数的操作是合法的，它就可以使用于任何参数类型。	函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是不同的。
调试	宏是不方便调试的	函数是可以逐语句调试的
递归	宏是不能递归的	函数是可以递归的

命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。

那我们平时的一个习惯是：

#undef

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define M 100
int main()
{
	int a = M;
#undef M
	printf("%d\n", M);

	return 0;
}

这条指令用于移除一个宏定义。

命令行定义

许多 C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。

gcc test.c -D M=10

条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。

比如说：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define PRINT 1
int main()
{

#if PRINT
	printf("hehe\n");
#endif

	return 0;
}

#if和#endif
这里的#if + 真假

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
#if 1==2
	printf("hehe\n");
#elif 2==3
	printf("haha\n");
#else 
	printf("heihei\n");
#endif
	return 0;
}

#if和#elif和#else和#endif
#if和#elif + 真假

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define TEST 0
#define HEHE 1
int main()
{
//如果TEST定义了，下面参与编译
//1
#ifdef TEST
	printf("test1\n");
#endif
//2
#if defined(TEST)
	printf("test2\n");
#endif

	return 0;
}

这里的#ifdef，#endif和#if defined()，#endif是同一个意思
#ifdef+符号定义就执行

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define TEST 0
#define HEHE 1
int main()
{
	//如果HEHE不定义，下面参与编译
	//3
	#ifndef HEHE
	printf("hehe1\n");
	#endif
	//4
	#if !defined(HEHE)
	printf("hehe2\n");
	#endif

	return 0;
}