gta5买办公室 网站正在建设,不建网站可不可以做cpa,在哪里找给公司做网站优化的人,武义建设局网站1、预定义符号
C语言设置了一些预定义符号#xff0c;可以直接使用。预定义符号也是在预处理期间处理的。
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI…1、预定义符号
C语言设置了一些预定义符号可以直接使用。预定义符号也是在预处理期间处理的。
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C其值为1, 否则未定义
举个例子
#include stdio.h
int main()
{printf(进行编译的源文件:%s\n, __FILE__);printf(当前文件的行号:%d\n, __LINE__);printf(当前文件编译日期:%s\n, __DATE__);printf(当前文件编译时间:%s\n, __TIME__);return 0;
}
运行: __STDE__只有在编译器遵循ANSI C时才为1但是VS使用该标识符是未定义的说明VS并不支持ANSI C 2、#define 定义常量
基本语法
#define name stuff
举个例子
#define MAX 1000
#define reg register //为register这个关键字,创建一个简短的名字
#define do_forerer for(;;) //定义一个死循环的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__)
思考在define定义标识符的时候要不要在最后加上
比如
#define MAX 1000;
#define MAX 1000
建议不要加上这样容易导致问题
比如下面场景
if(condition)max MAX;
elsemax 0;
如果是加上了分号的情况等替换后if和else之间就是2条语句而没有大括号的时候if后边只能有一条语句。这里会出现语法错误。
替换后
if(condition)
max 1000;;
else
max 0;
因为1000后面多出了一个而多出的这个会被当做一条空语句看似一条语句实则两条语句所以使用时一定要注意#define定义的标识符后面尽量不加分号。
总结#define定义标识符的后面的可以是常量、字符、浮点数、字符串、关键字或一段代码等... 3、#define定义宏
define不止可以定义常量还可以定义宏。
#define机制包括了一个规定允许把参数替换到文本中这种实现通常称为宏macro或定义宏define macro。
下面是宏的申明方式
#define name(parament-list) stuff
其中的parament-list是一个由逗号隔开的符号表它们可能出现在stuff中。 注意 参数列表的左括号必须与name紧邻如果两者之间有任何空白存在参数列表就会被解释为stuff的一部分。 那宏怎么使用呢举个例子
#include stdio.h
#define SQAURE(X) X*X//假设我要计算一个数的平方而使用define定义一个宏
int main()
{int a 5;printf(%d\n, SQAURE(a));//传一个参数过去当经过预处理阶段时会替换成我们定义的表达式return 0;
}
这样来看是不是感觉宏和函数的使用方式有一些相似。
其实宏的计算和函数有点不一样的是将参数传给宏并不是在宏里完成表达式计算返回值而是在预处理阶段将调用宏的地方替换成宏定义的表达式。
例如
#include stdio.h
int main()
{int a 5;printf(%d\n, a*a);//预处理阶段展开#define定义并替换return 0;
}
警告
这个宏存在一个问题
观察下面的代码段
#include stdio.h
#define SQAURE(X) X*X//假设我要计算一个数的平方而使用define定义一个宏
int main()
{int a 5;printf(%d\n, SQAURE(a2));//传一个参数过去当经过预处理阶段时会替换成我们定义的表达式return 0;
}
我们想象的结果是a2也就是7的开平方49实际上结果是17为什么
因为我们给宏传参传表达式并不是计算完成后在计算宏而是在预处理阶段直接将我们传参的表达式替换到宏定义的表达式。
例如
#include stdio.h
int main()
{int a 5;printf(%d\n, 7*7);//我们想象的printf(%d\n,a2*a2);//预处理阶段实际做的return 0;
}
解决方法所以我们使用宏时一定要注意当定义宏的表达式时一定要用括号将表达式中的参数单个括起来说不定这个参数本身也是一个表达式。
比如
#include stdio.h
#define SQAURE(X) ((X)(X))//宏的整体也括一下
//因为调用宏的位置说不定是在某表达式中调用因为操作符优先级导致计算顺序并不能达到我们的预期
int main()
{int a 5;printf(%d\n, 2*SQAURE(a2));printf(%d\n,2*((a2)(a2)));//预处理阶段替换return 0;
}
记得把宏定义表达式整体也括一下这样才能保证先运算宏定义的表达式。 4、带有副作用的宏参数
当宏参数在宏的定义中出现超过一次的时候如果参数带有副作用那么你在使用这个宏的时候就可能出现危险导致不可预测的后果。副作用表达式求值的时候出现的永久性效果。
例如
x1; //不带副作用
x; //带副作用
什么是带有副作用的表达式呢就是我想解决一件问题但却因此留下了另一个问题。就比如我感冒了我开了点感冒药。吃完感冒药后感冒是好了但是胃又因此不舒服了这就是副作用。
例如
#include stdio.h
int main()
{int a 10;int b a;//我想得到a1的值11,使用a是得到了11但是因此a也发生了改变printf(a%d b%d\n, a, b);//结果:11,11return 0;
}
这就是带有副作用的表达式。
那如果宏参数是带有副作用的表达式会发生什么呢
举个例子
#include stdio.h
#define MAX(a, b) ((a)(b)?(a):(b));
int main()
{int a 15;int b 9;int m MAX(a,b);printf(m%d\n, m);printf(a%d b%d\n, a, b);//再猜一下a和b的值是多少return 0;
}
最后的结果是什么呢
运行结果m16, a17, b 10
为什么看下面解析
#include stdio.h
int main()
{int a 15;int b 9;int m ((a)(b)?(a):(b));//预处理替换后printf(m%d\n, m);printf(a%d b%d\n, a, b);return 0;
}
代码解析首先判断(a)(b)此时是转换成159来进行判断的因为先使用后当159成立该表达式就返回a此时a是16因为先使用后就先返回16m就拿到了16所以m16然后a就是17前后a了两次b了一次所以a17, b10 总结 1、宏的参数是如果是表达式不会计算的。和函数相反函数是先将表达式参数进行运算将运算结果作为参数传参。 2、宏是直接将参数原封不动的替换到宏定义的表达式中的。 宏的参数是不参与计算的当我们给宏的参数传递一个表达式时并不是将表达式计算结果进行计算而是在预处理阶段直接将表达式参数替换到宏定义的表达式然后再替换到调用宏的位置。 5、宏的替换规则
在程序中扩展#define定义符号和宏是需要涉及几个步骤。
1. 在调用宏时首先对参数进行检查看看是否包含任何由#define定义的符号如果是它们首先被替换。
2. 替换文本后被插入到程序中原来文本的位置对于宏参数名被他们的值所替换。
3. 最后再次对结果文件进行扫描看看它是否包含任何由#define的符号。如果是就重复上述处理过程。
注意
1. 宏参数和#define定义中出现其他#define定义的符号。但是对于宏不能出现递归。
2. 当预处理器搜索#define定义的符号的时候字符串常量的内容并不被搜索。 6、宏和函数的对比
宏通常被应用于执行简单的运算。
比如在两个数中找出较大的一个时写成下面的宏更有优势一些。
#define MAX(a, b) ((a)(b)?(a):(b))
那为什么不用函数来完成这个任务呢
原因有二
1. 用于调用函数和从函数返回的代码可能比实际指向这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和所读方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏可以适用于整型、长整型、浮点型等可以用于来比较的类型。宏是类型无关的。 和函数相比宏的劣势 1. 每次使用宏的时候一份宏定义的代码将插入到程序中。除非宏比较短否则可能大幅度增加程序的长度。 2. 宏是没法调试的 3. 宏由于类型无关也就不够严谨。 4. 宏可能会带来运算符优先级的问题导致容易出现错误。 看到这里感觉函数和宏之间各有千秋函数有函数的好处宏有宏的好处那宏有没有什么事函数做不到的呢当然有。
宏有时候可以做到函数做不到的事情。比如宏的参数可以出现类型但是函数做不到。
#define MALLOC(num, type) \(type*)malloc(num * sizeof(type))
...
//使用
int* a MALLOC(10,int);//类型作为参数//预处理器替换之后
int* a (int*)malloc(10 * sizeof(int)); 宏和函数的一个对比
属性#define定义宏函数代码长度 每次使用时宏代码都会被插入到程序中。 除非非常小的宏之外程序的长度会大幅度 增长 函数代码只出现于一个地方每次使用函 数时都调用那个地方的同一份代码 执行速度更快 存在函数的调用和返回的额外开销所以 相对慢一些 操作符优先级 宏参数的求值是在所有周围表达式的上下文 环境里除非加上括号否则邻近操作符的 优先级可能会产生不可预料的后果所以建 议宏在书写的时候多写括号 函数参数只在函数调用的时候求值一次 它的结果值传递给函数。表达式的求值 结果更容易预测 带有副作用的参数 参数可能被替换到宏体中的多个为止如 果宏的参数被多次计算带有副作用的参数 可能会产生不可预料的结果 函数参数只在传参的时候求值一次结果 更容易控制 参数类型 宏的参数与类型无关只要对参数的操作是 合法的他就可以使用任何参数类型 函数的参数是与类型有关的如果参数的 类型不同就需要不同的函数即使他们 执行的任务是不同的。 调试宏是不方便调试的 函数是可以逐语句调试的 递归宏是不可以递归的函数是可以递归的 那什么时候该有宏什么时候该有函数呢 如果计算逻辑比较简单就可以使用宏。如果计算逻辑比较复杂就可以使用函数。 7、#和##
7.1 #运算符
#既不是#include或#define中的#又不是、-、*、/中的运算符。#是预处理中的一种运算符。
#运算符将宏的一个参数转换为字符串字面量它仅允许出现在带参数的宏的替换列表中#运算符所执行的操作可以理解为字符串化。 printf的特性 这里首先要了解一下printf函数还有一个特性就是当我们给printf传两个或多个字符串时printf会自动将它们参数合并成一个字符串并输出举个例子 可以看到第二次调用printf将hello world\n分成两个字符串可是printf自动将这两个字符串合并成一个。 知道了printf的这个特性我们就可以继续向下学习。
知道了#运算符可以在宏体中将宏的参数转换成字符串我们就可以写下面这样代码
#include stdio.h
#define Print(n, format)\printf(the value of #n is format \n, n)
int main()
{char c a;Print(c, %c);printf(the value of c is %c \n, c);//预处理阶段替换后int n 10;Print(n, %d);printf(the value of n is %d \n, n);//预处理阶段替换后float f 3.14f;Print(f, %f);printf(the value of f is %f \n, f);//预处理阶段替换后return 0;
}
运行结果 因为#运算符修饰的参数本来就是字符串化如果n是变量c那#n就c如果n是变量a那#n就是a如果n是变量f那#n就是f所以#n经过预处理阶段就会替换为 a 所以不需要再#n的套一层字符串。
7.2 ## 运算符
## 可以把位于它两边的符号合成一个符号它允许宏定义从分离的文本片段创建标识符## 被称为记号粘合这样的连接必须产生一个合法的标识符否则器结果就是未定义的。
这里我们想想写一个函数求2个数的较大值的时候不同的数据类型就得写不同的函数。
比如
int int_max(int x, int y)
{return xy?x:y;
}float float_max(int x, int y)
{return xy?x:y;
}
但是这样写起来太繁琐了现在我们这样写代码试试
//宏定义
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{ \return (xy?x:y); \
} \
使用宏定义不同类型
//预处理前的程序格式
#define GENERIC_MAX(type)\
type type##_max(type x, type y)\
{\
return (xy?x:y);\
}
//下面两行代码是使用宏定义两个自定义函数
GENERIC_MAX(int)
GENERIC_MAX(float)
int main()
{int a 10;int b 20;int ret int_max(a, b);printf(%d\n, ret);float c 11.1f;float d 22.2f;float fret float_max(c, d);printf(%.2f\n, fret);return 0;
}//预处理后的程序格式
int int_max(int x, int y)
{return (xy?x:y);
}
float float_max(float x, float y)
{return (xy?x:y);
}
int main()
{int a 10;int b 20;int ret int_max(a, b);printf(%d\n, ret);float c 11.1f;float d 22.2f;float fret float_max(c, d);printf(%.2f\n, fret);return 0;
} 8、命名约定
一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区分二者
那我们平时的一个习惯是 把宏名全部大写 函数名不用全部大写 9、#undef
这条指令又能与移除一个#define的标识符定义或宏定义
#undef NAME
//如果现存的一个名字需要被重新定义那么它的就名字首先要被移除
#undef的使用
#define M 100
int main()
{int a M;//a 100//当想使用M这个标识符名字重新定义
#undef M//移除标识符M的定义
#define M 200int b M;//b 200printf(a%d b%d\n, a, b);return 0;
} 10、命令行定义
许多C 的编译器提供了一种能力允许在命令行中定义符号。用于启动编译过程。
例如当我们根据同一个源文件要编译出一个程序的不同版本的时候这个特性有点用处假设某个程序中声明了一个某个长度的数组如果机器内存有限我们需要一个很小的数组但是另一个机器内存大些我们需要一个数组能够大些
注VS是不支持命令行定义的只能在gcc下观察。
#include stdio.h
int main()
{int array[ARRAY_SIZE];//ARRAY_SIZE可以在源文件中定义也可以在命令行中输入命令来定义int i 0;for (i 0; i ARRAY_SIZE; i){array[i] i;}for (i 0; i ARRAY_SIZE; i){printf(%d , array[i]);}return 0;
}
编译指令
//Linux 环境演示
gcc -D ARRAY_SIZE 10 programe.c//-D是定义命令后面定义一个标识符再在标识符后面输入一个值//ARRAY_SIZE是标识符 100是标识符的常量//programe.c是当前源文件的文件名 11、条件编译
在编译一个程序的时候我们如果要将一条语句一组语句编译或者放弃是很方便的。因为我们有条件编译指令。
注条件编译后的只能是常量或常量表达式来进行判断不能使用变量来进行判断。 比如说 调试性的代码删除可惜保留又碍事所以我们可以选择性的编译。 满足条件就编译 不满足条件就放弃编译 常见的条件编译指令
1.条件编译
#if 常量表达式//...
#endif
//常量表达式由预处理器求值
如
#define __DEBUG__ 1
#if __DEBUG__//...
#endif2.多个分支的条件编译
#if 常量表达式//...
#elif 常量表达式//...
#else//...
#endif3.判断是否被定义
#if defined(symbol)
#ifdef symbol#if !defined(symbol)
#ifndef symbol4.嵌套指令
#if defined(OS_UNIX)#ifdef OPTION1unix_version_option1();#endif#ifdef OPTION2unix_version_option2();#endif
#elif defined(OS_MSDOS)#ifdef OPTION2msdos_version_option2();#endif
#endif
11.1 条件编译
那我们是怎么使用的呢看下面代码
#include stdio.h
#define flag 1
int main()
{
//flag 1
#if flagprintf(hello world---1\n);
#endif
//!flag 0
#if !flag printf(hello world---2\n);
#endifreturn 0;
}
运行结果 if 和 #if 的区别 如果if判断为真则执行if中的语句if为假则不执行if中的语句。 如果#if判断为真预处理阶段就保留#if中的语句如果为假则在预处理阶段删除#if中的语句。 所以上面代码经过预处理后是这样的
int main()
{printf(hello world---1\n);return 0;
}
因为只有第一条#if判断为真所以这条语句被保留了下来第二条#if判断为假则删除语句。
注条件编译完最后记得加上一条#endif来表示条件编译结束。
11.2 多分支条件编译
多分支条件编译不管有多少条编译总归得执行一条例如
#include stdio.h
#define flag 17
int main()
{#if flag%3 1printf(flag取模3的余数为1\n);
#elif flag%3 2printf(flag取模3的余数为2\n);
#else printf(flag取模3的余数为0\n);
#endifreturn 0;
}
运行结果 和if、else if、else的使用方法相似只是功能不一样。
所以这条代码经过预处理后是这个格式
int main()
{printf(flag取模3的余数为2\n);return 0;
}
11.3 判断是否被定义
#ifdef或#if defined()就是判断该标识符符有没有定义定义了就保留这条语句未定义就删除语句。而#ifndef或#if !defined()判断该标识符没有定义就保留语句定义了就删除语句。
#include stdio.h
#define MAX 100
int main()
{
#ifdef MAXprintf(MAX标识符已定义\n);
#endif//等价
#if defined(MAX)printf(MAX标识符已定义\n);
#endif//.........#ifndef MAXprintf(MAX标识符未定义\n);
#endif//等价
#if !defined(MAX)printf(MAX标识符未定义\n);
#endifreturn 0;
}
运行结果 所以这条代码经过预处理后是这个格式
int main()
{printf(MAX标识符已定义\n);return 0;
} 12、头文件的包含
12.1 头文件被包含方式
12.1.1 本地文件包含
#include filename.h
查找策略先在源文件所在目录下查找如果该头文件未找到编译器就像查找库函数头文件一样在标准位置查找头文件。
如果找不到就提示编译错误。
Linux环境的标准头文件路径
/usr/include
VS环境的标准头文件路径:
c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径
注意按照自己的安装路径去找。 12.1.2 库文件包含
#include filename.h
查找头文件直接去标准路径下去查找如果找不到就提示编译错误。
那是不是可以说对于库文件也可以使用 的形式包含
#include stdio.h
答案是肯定的可以但是这样查找的效率就低些当然这样也不容易区分是库文件还是本地文件了。 12.2 嵌套文件包含
我们已经知道#include 指令可以使另一个文件被编译。就像它实际出现于#include 指令的地方一样。
这种替换的方式很简单预处理器先删除这条指令并用包含文件的内容替换。
一个头文件被包含10次那就实际被编译10次如果重复包含对编译的压力就比较大。 test.c源文件 #include test.h
#include test.h
#include test.h
#include test.h
#include test.h
int main()
{return 0;
} test.h头文件 void test();
struct stu
{int id;char name[20];
}; 如果直接这样写test.c文件中将test.h包含5次那么test.h文件的内容将会被拷贝5份在test.c中。
如果test.h文件比较大这样预处理后代码会剧增。如果工程比较大有公共使用的头文件大家
都能使用如何解决头文件被重复引入的问题呢答案条件编译
#ifndef __TEST_H__
#define __TEST_H__
//头文件内容
#endif //__TEST_H__
或者
#pragma once
就可以避免头文件的重复引入。
注
推荐《高质量C/C编程指南》中附录的考试试卷很重要. 笔试题 1. 头文件中的 ifndef / define /endif是干什么用的 答是用来避免重复头文件重复包含的ifndef判断标识符是否定义如果未定义就继续向下编译知道endif为止。中间使用define定义ifndef所判断的标识符下一次再包含头文件属于重复包含但是因为第一次包含时顺便定义了该标识符所以第二次包含时不会通过ifndefifndef会在预处理阶段将头文件一下内容删除不会再被编译进包含该头文件的文件里。 2. #include filename.h 和 #include filename.h有什么区别 答区别是所包含的头文件只寻找1次而 包含的头文件寻找2次。说明包含的头文件是标准库中的头文件便会直接去标准库中寻找找不到就编译错误并不会额外花费时间去本地文件路径找。 说明包含的头文件是本地文件会先去本地文件路径下寻找如果未找到就去标准库找找了2次。 13、其他预处理指令
#error
#pragma
#line
...
不做介绍可以自己去了解#pragme pack()在结构体部分介绍过了
14、offsetof模拟实现
offsetof是宏定义参数就给它一个结构体类型然后再给一个成员名它就可以求出该成员在结构体类型中内存对齐的偏移量。偏移量就是结构体的起始地址和内存对齐后变量的地址之间的距离。单位是字节byte。
假设我们把0作为结构体的起始地址那其他的成员的地址就是偏移量。有了思路我们就可以模拟offsetof了
#include stdio.h
#define OFFSETOF(type,mem) (size_t)(((type*)0)-mem)
//假设结构体的地址是0通过0这个地址-找到成员取地址取出的就是偏移量。
//此时这个取出偏移量还是地址将这个地址强制类型转换成(size_t)无符号整型。
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;
}
如果结构体的起始位置从0开始的话那它成员的位置地址刚好就可以表示偏移量。 C99后 引入了一个概念内联函数(inline) 内联函数具有了函数的特点也具有了宏的特点 函数的特点参数、返回值 宏的特点和宏一样在调用内联函数的地方展开 学习C时可以学到 C语言第17篇预处理详解 到这里也就结束了我们下一篇笔记再见-
