IOS开发学习笔记008-预处理

预处理

1、宏定义

2、条件编译

3、文件包含

注意：

　　1、所有预处理都是以#开头，并且结尾不用分号.

　　2、宏名一般用大写字母，以便与变量名区别开来，但用小写也没有语法错误

　　3、作用域也是从定义到代码块结束

　　4、定义一个宏时可以引用已经定义的宏名

　　5、在编译预处理用字符串替换宏名时，不作语法检查，只是简单的字符串替换。只有在编译的时候才对已经展开宏名的源程序进行语法检查

一、宏定义

　　1、不带参数的宏定义

　　#define 宏名 字符串

　　#define COUNT 6　　

　　2、带参数的宏定义

　　#define 宏名(参数列表) 字符串

　　#define sum(va,vb) ((va)+(vb))

　　注意：每个参数都要加括号，运算结果也要加括号

若需要提前取消宏定义可用 #undef COUNT实现。

　　代码示例

 //宏名一般用大写字母，以便与变量名区别开来，但用小写也没有语法错误
 //1、宏定义1,不带参数的宏定义，常用来定义常量
 #define COUNT 6//后面么有';'

 #include <stdio.h>
 //1、宏定义2，带参数的宏定义,每个参数都要加括号，运算结果也要加括号
 #define sum(v1,v2) ((v1)+(v2))

 int main()
 {
     //1、宏定义使用
     int array[COUNT] = {,,,,,};
     for (int i = ; i < COUNT; i++)
     {
         printf("%d ",array[i]);
     }
 #undef COUNT    //提前取消宏定义
     //带参数的宏
     printf("\n%d\n",sum(,));
     printf("%d\n",sum(,)*sum(,));//这样实际运行效果是3+3*4+4=19,因为宏只是简单的文本替换，所以定义时加()比较好

     //2、条件编译

     return ;
 }

二、条件编译

满足条件就对代码进行编译，否则不编译。

#if 条件1

　.....

#elif 条件

　　......

#else

　　.....

#endif//不可缺少

 #define COUNT 6//后面么有';'
   //2、条件编译,一般判断宏的值，不能对变量进行操作
 #if(COUNT  == 6)
     printf("条件编译:%d\n",COUNT);
 #elif (COUNT  == 4)

 #else

 #endif//不可缺少

#if defined()和#if !defined()的使用

#if defined(COUNT)//COUNT是一个宏，如果定义这个宏就执行下面的代码
 ...code...
#endif

#if !defined(COUNT)//COUNT是一个宏，如果没有定义这个宏就执行下面的代码
 ...code...
#endif

代码：

 //#if defined()和#if !defined()的用法
 #if defined (COUNT)//如果定义宏就编译下面代码，否则不编译
     printf("defined:%d\n",COUNT);
 #endif

 #if !defined (COUNT1)//如果定义宏就编译下面代码，否则不编译
     printf("! defined\n");
 #endif

#ifdef和#ifndef的使用

#ifdef COUNT//COUNT是一个宏，如果定义这个宏就编译下面的代码
  ...code...
#endif

#ifndef COUNT//COUNT是一个宏，如果没有定义这个宏就编译下面的代码
  ...code...
#endif

代码：

 //#ifdef和#ifndef的使用
 #ifdef COUNT//如果定义宏就编译下面代码，否则不编译
      printf("ifdef:%d\n",COUNT);
 #endif

 #ifndef COUNT1//如果定义宏就编译下面代码，否则不编译
     printf("ifndef\n");
 #endif

三、文件包含

#include

#include <>//系统头文件

#include ""//自定义的头文件

文件包含可能会重复包含同一个文件，这是可以再要包含的文件中添加一个宏定义，用于消除重复包含。

格式如下　　

　　#ifndef A_H

　　#def A_H

　　　　..........

　　#endif

这样即使多次#include同一个头文件也不会产生文件的重复性包含

 四、typedef 

typedef的用法:

 　　1、为各种数据类型定义一个新名字(别名)

 　　2、typedef与指针

 　　3、typedef与结构体

 　　4、typedef与指向结构体的指针

　　 5、typedef与枚举类型

　　 6、typedef与指向函数的指针

　　 7、typedef与#define

代码示例

 #include <stdio.h>
 /*
  typedef的用法:
  1、为各种数据类型定义一个新名字(别名)
  2、typedef与指针
  3、typedef与结构体
  4、typedef与指向结构体的指针
  5、typedef与枚举类型
  6、typedef与指向函数的指针
  7、typedef与#define
 */

 //3、typedef与结构体
 struct Point
 {
     int x;
     int y;
 };

 //也可以直接在定义时使用typedef
 typedef struct Point1{}point1;

 //起别名，下面可以直接使用，而不用每次都写struct
 typedef struct Point MyPoint;

 //自定义结构体指针，起别名
 typedef MyPoint *pp;

 // 5、typedef与枚举类型
 enum Sex{male,female,notSure};
 typedef enum Sex Sex;//起别名

 // 6、typedef与指向函数的指针
 int Sum(int a,int b)
 {
     int c = a + b;
     printf("%d + %d = %d\n",a,b,c);
     return c;
 }

 int main()
 {
     //1、为各种数据类型定义一个新名字(别名)
     typedef int Integer;

     Integer i = ;
     printf("%d\n",i);

     //1、typedef与指针
     typedef char *String;
     String name = "this is a typedef struct";
     printf("%s\n",name);

     //3、typedef与结构体
     MyPoint p1;
     p1.x = ;
     p1.y = ;
     printf("%d,%d\n",p1.x,p1.y);

     //4、typedef与指向结构体的指针
     pp p = &p1;
     p->x = ;
     p->y = ;
     printf("%d,%d\n",p->x,p->y);

     // 5、typedef与枚举类型
     Sex s1 = male;//使用别名进行变量声明，不用带关键字enum
     printf("%d\n",s1);

     // 6、typedef与指向函数的指针
     //普通函数指针使用方式
     int (*pSum)(int ,int );//普通函数指针定义
     pSum = &Sum;
     (*pSum)(,);

     typedef int (*pS)(int ,int );//使用typedef给函数指针起别名
     pS ps = &Sum;//这个使用方式和上面有些差别
     (*ps)(,);

     //7、typedef与#define
 #define String1 char*
     typedef char* String2;
     String1 str1,str2;//宏替换 char* str1,str2;//str2只是一个字符变量，不是指针变量
     String2 str3,str4; //但是这个是这样，char *str3；char * str4;

     return ;
 }

static和extern

static和extern与函数

　　关于函数：

　　外部函数：如果在当前文件中定义的函数允许其他文件访问、调用，就称为外部函数。C语言规定，不允许有同名的外部函数。

　　内部函数：如果在当前文件中定义的函数不允许其他文件访问、调用，只能在内部使用，就称为内部函数。C语言规定不同的源文件可以有同名的内部函数，并且互不干扰。

one.h

//one.h

#include "one.c"

extern void one();
void anotherOne();

one.c

 //one.c

 #include <stdio.h>

 extern void one()//默认就是extern函数，不写效果一样。外部函数
 {
     printf("one is called！\n");
 }
 static void anotherOne()//只能在one.c中使用。内部函数
 {
     printf("anotherOne is called！\n");
 }

主函数

 #include <stdio.h>
 //#include "one.h"
 /*
  extern与static
  1、extern与函数==外部函数
  2、static与函数==内部函数
  */

 //1、extern与函数
 //#include "one.c"//这样引用会提示重复定义one
 //extern void one();//可以这样进行外部声明，但是extern可以省略，所以可以直接写成 void one()；
     //实际情况下一般把声明写道头文件里，直接包含头文件，可以直接使用里面的函数
 // 2、static与函数
     //只能再定义的文件内使用，无法被外部文件引用

 void anotherOne();//引用声明

 int main()
 {
     one();
     anotherOne();
     return ;
 }

static和extern与全局变量

1、全局变量可以重复定义，只要变量名一样，指的都是一个变量，在多个文件中也是如此。

　　int b1;

　　int b1;

　　int b1;

2、如果变量的定义在下面，但是又想提前使用就需extern声明

　　extern int a;

3、在函数内部也可以通过extern int a;使用全局变量a，以区别同名的局部变量

4、全局静态变量，只能在本文件内部使用

 #include <stdio.h>
 //3、全局变量和static
 static int b;//全局静态变量，只能在本文件内部使用
 //全局变量可以重复定义，只要变量名一样，指的都是一个变量，在多个文件中也是如此。
 int b1;
 int b1;
 int b1;
 // 4、全局变量和extern
 extern int a;//a的定义在下面或者在其他文件里，如果想提前使用就需extern声明

 int main()
 {
     {
         //在函数内部访问同名全局变量1
         extern int b1;
         b1 = ;
     }
      //在函数内部访问同名全局变量2
     int *p = &b1;

     int b1;
     b1 = ;

     return ;
 }

 int a;

2015-4-14 今日如此，明日依旧。