程序环境和预处理(Program environment and processing)

目录

程序环境和预处理：：

                                1.程序的翻译环境和执行环境

                                2.编译和链接

                                3.预定义符号介绍与#define定义标识符

                                4.#define宏与宏和函数的对比

                                5.命令行定义

                                6.条件编译

                                7.文件包含

                                8.百度笔试题解析

程序环境和预处理：：

1.程序的翻译环境和执行环境

在ANSIC的任何一种实现中，存在两个不同的环境.

第一种是翻译环境，在这个环境中源代码被替换为可执行的机器指令.

第二种是执行环境，它用于实际执行代码.

2.编译和链接

翻译环境：

组成一个程序的每个源文件通过编译过程分别转化成目标文件，链接器再将每个目标文件捆绑在一起，形成一个单一而完整的程序，链接器同时会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到库中.

注：VS中的编译器是cl.exe VS中的链接器是 link.exe.

编译的阶段：

1.两步：编译+链接 

2.四步：预处理+编译+汇编+链接 

gcc编译过程：

分步编译：

Linux按照elf格式来组织它的文件内容。合并段表：把相同格式下的数据进行合并。

执行环境：

程序执行的过程：

1.程序必须载入内存中，在有操作系统的环境中：一般这个由操作系统完成，在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码植入只读内存来完成.

2.程序的执行便开始，接着便调用main函数.

3.开始执行程序代码，这个时候将使用一个运行时堆栈(函数栈帧)，存储函数的局部变量和返回地址，程序同时也可以使用静态(static)内存，存储静态内存中的变量，在程序的整个执行过程一直保留他们的值.

4.终止程序，正常终止main函数，也可能是意外终止.

3.预定义符号介绍与#define定义标识符

预定义符号： 

日后VS和gcc运行结果不一样时，请遵循gcc的语法规则，因为gcc是遵循ANSIC标准的

注：clang是苹果公司维护的编译器

int main()
{
	int i = 0;
	FILE* pf = fopen("log.txt", "w");
	if (pf == NULL)
	{
		perror("fopen fail");
		return EXIT_FAILURE;//EXIT_FAILURE 1 EXIT_SUCCESS 0
	}
	for (i = 0; i < 10; i++)
	{
		fprintf(pf,"file:%s line=%d date=%s time=%s  i=%d\n", __FILE__, __LINE__, __DATE__, __TIME__ ,i);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

#define定义的标识符

//语法：#define name stuff
#define MAX 1000
#define reg register       //为register这个关键字，创建一个简短的名字
#define do_forever for(;;) //用更形象的符号来替换一种实现
#define CASE break;case    //在写case语句的时候自动把 break写上。
//如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
                          date:%s\ttime:%s\n" ,\
                          __FILE__,__LINE__ ,  \
                          __DATE__,__TIME__ )  
//续航符的功能是转义\n，所以续航符的后面不允许加任何东西

4.#define宏与宏和函数的对比

宏的定义：

#define机制包括了一个规定，允许把参数替换到文本，这种实现称为宏。(宏是带有参数的)

#define SQUARE(X) ((X)*(X)) //计算的是X*X的结果
//参数前面的左括号必须和宏名连在一起
#define DOUBLE(X) ((X)+(X))

#define替换规则
步骤一：在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号，如果是首先被做替换

步骤二：替换文本随后被插入到程序中原来文本的位置，对于宏，参数名被他们的值替换

步骤三：最后再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号，如果是就重复上述处理过程

注意：1.宏参数和#define定义中可以出现其他#define定义的符号，但是对于宏，不能出现递归，即自己调用自己

           2.当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索，即字符串里面出现宏的内容并不被替换
#和##的作用：

#的作用是把一个宏参数变成对应的字符串插入到宏的内容中.

#define PRINT(N) printf("the value of "#N" is %d\n",N)
int main()
{
	int a = 10;
	PRINT(a);
	int b = 20;
	PRINT(b);
	return 0;
}
#define PRINT(N,FORMAT) printf("the value of "#N" is "FORMAT,N)
int main()
{
	int a = 10;
	PRINT(a, "%d\n");
	float f = 3.14f;
	PRINT(f, "%f\n");;
	return 0;
}

##的作用：##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符.

#define CAT(Class,Num) Class##Num
int main()
{
	int Class01 = 100;
	printf("%d\n", CAT(Class, 01));
	//printf("%d\n", Class01);
	return 0;
}

带副作用的宏参数：

//下列程序的运行结果为:
#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
	int a = 5;
	int b = 4;
	int m = MAX(a++, b++);//注意宏参数传进去不是计算而是替换
	printf("%d\n", m);//6
	printf("a=%d,b=%d", a, b);//7 5
	return 0;
}
//程序的运行结果为:m=6 a=7 b=5
//a++ b++这种带副作用的宏参数传进宏时不止影响一次

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

宏和函数的对比：
宏通常被用于简单的计算

原因有二：

1.一方面调用函数建立栈帧可能比实际执行这个小型计算工作所需要的时间更多，所以宏比函数在程序的规模和速度方面更胜一筹。
2.更为重要的是函数的参数必须声明为特定的类型，所以函数只能在类型合适的表达式上使用，而
宏在预处理期间就已经完成替换，而函数要在编译期间才执行。

宏的缺点：
1.每次使用宏的时候，一份宏定义的代码插入到程序中，除非宏比较短，否则可能大幅度增加程序的长度
2.宏是无法进行调试的
3.宏由于类型无关，也不够严谨
4.宏可能会带来运算符优先级的问题，导致容易出错

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

#define MALLOC(num,type) (type*)malloc((num)*sizeof(type))
int main()
{
	int* p = MALLOC(10, int);//只有宏才可以传数据类型 
	return 0;
}

命名约定：
一般来讲，函数和宏的使用语法很相似，所以语言本身没法帮我们区分二者，我们平时的习惯是 把宏名全部大写，函数名不要全部大写，但并不一定所有宏都大写，如offsetof

#undef用于移除一个宏定义

#undef NAME
//如果现存的一个名字需要被重新定义，那么它的名字首先要被移除

5.命令行定义

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

例如：当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处，假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组也能够大些。

#include 
int main()
{
    int arr [ARRAY_SIZE];
    int i = 0;
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        arr[i] = i;
   }
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        printf("%d " ,arr[i]);
   }
    printf("\n" );
    return 0;
}

//编译指令：
//linux 环境演示：
//gcc -D ARRAY_SIZE=10 programe.c

6.条件编译

在编译一个程序的时候，我们需要将一条语句(一组语句)编译或者放弃是很方便的，因为我们有条件编译指令（预处理阶段进行条件编译的时候，满足条件的代码留下，其余的就都被过滤掉了）

//比如说：调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。
#include 
#define __DEBUG__
int main()
{
    int i = 0;
    int arr[10] = {0};
    for(i=0; i<10; i++)
    {
         arr[i] = i;
         #ifdef __DEBUG__
         printf("%d ", arr[i]);//为了观察数组是否赋值成功。 
         #endif //__DEBUG__
    }
    return 0;
}

1.
#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值。
//如：
#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif
//2.多个分支的条件编译
#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif
//3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
//4.嵌套指令
#if defined(OS_UNIX)
 #ifdef OPTION1
 unix_version_option1();
 #endif
 #ifdef OPTION2
 unix_version_option2();
 #endif
#elif defined(OS_MSDOS)
 #ifdef OPTION2
 msdos_version_option2();
 #endif
#endif

7.文件包含

//防止头文件重复包含的两种方式:
1.#pragma once
2.#ifndef __TEST_H__
  #define __TEST_H__
  //头文件的所有内容
  #endif
//<>和""的区别是查找策略的不同
//如果头文件写成<>的查找策略:直接去库目录下查找 
//""的查找策略:1.先去代码所在路径下查找 2.如果上面找不到再去库目录下查找
//#include"stdio.h"可以但效率慢

8.百度笔试题解析

offsetof的讲解：

//offsetof(type,member)
//头文件为#include
#include
struct S
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%d\n",offsetof(struct S, c1));//宏的参数可以传类型
	printf("%d\n",offsetof(struct S, i));
	printf("%d\n",offsetof(struct S, c2));
	return 0;
}

写一个宏，计算结构体中某变量相对于首地址的偏移，并给出说明

//模拟实现offsetof
//思路:假设起始位置是0 结构体成员的地址和偏移量是相同的
struct S
{
	char c1;
	int i;
	char c2;
};
#define OFFSETOF(type,m_name) (size_t)&(((type*)0)->m_name)
int main()
{
	printf("%d\n", OFFSETOF(struct S, c1));
	printf("%d\n", OFFSETOF(struct S, i));
	printf("%d\n", OFFSETOF(struct S, c2));
	return 0;
}
//注：通过谁的地址去访问数据 那访问的起始位置就是谁的地址

写一个宏，可以将一个整数的二进制位的奇数位和偶数位交换

#define SWAP_BIN(n) (((n&0X55555555)<<1)+((n&0xaaaaaaaa)>>1))
int main()
{
    int n = 0;
    scanf("%d", &n);
    printf("%d\n", SWAP_BIN(n));
    return 0;
}