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] = {1,2,3,4,5,6};
    for (int i = 0; i < COUNT; i++)
    {
        printf("%d ",array[i]);
    }
#undef COUNT    //提前取消宏定义
    //带参数的宏
    printf("
%d
",sum(10,20));
    printf("%d
",sum(3,3)*sum(4,4));//这样实际运行效果是3+3*4+4=19,因为宏只是简单的文本替换，所以定义时加()比较好

    //2、条件编译
    
    
    return 0;
}

二、条件编译

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

#if 条件1

　.....

#elif 条件

　　......

#else

　　.....

#endif//不可缺少

#define COUNT 6//后面么有';'
  //2、条件编译,一般判断宏的值，不能对变量进行操作
#if(COUNT  == 6)
    printf("条件编译:%d
",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
",COUNT);
#endif
    
#if !defined (COUNT1)//如果定义宏就编译下面代码，否则不编译
    printf("! defined
");
#endif

#ifdef和#ifndef的使用

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

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

代码：

//#ifdef和#ifndef的使用
#ifdef COUNT//如果定义宏就编译下面代码，否则不编译
     printf("ifdef:%d
",COUNT);
#endif
 
#ifndef COUNT1//如果定义宏就编译下面代码，否则不编译
    printf("ifndef
");
#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
",a,b,c);
    return c;
}



int main()
{
    //1、为各种数据类型定义一个新名字(别名)
    typedef int Integer;
    
    Integer i = 10;
    printf("%d
",i);
    
    //1、typedef与指针
    typedef char *String;
    String name = "this is a typedef struct";
    printf("%s
",name);
    
    //3、typedef与结构体
    MyPoint p1;
    p1.x = 1;
    p1.y = 2;
    printf("%d,%d
",p1.x,p1.y);
    
    //4、typedef与指向结构体的指针
    pp p = &p1;
    p->x = 10;
    p->y = 20;
    printf("%d,%d
",p->x,p->y);

    // 5、typedef与枚举类型
    Sex s1 = male;//使用别名进行变量声明，不用带关键字enum
    printf("%d
",s1);
    
    // 6、typedef与指向函数的指针
    //普通函数指针使用方式
    int (*pSum)(int ,int );//普通函数指针定义
    pSum = &Sum;
    (*pSum)(19,20);
    
    typedef int (*pS)(int ,int );//使用typedef给函数指针起别名
    pS ps = &Sum;//这个使用方式和上面有些差别
    (*ps)(19,20);
    
    //7、typedef与#define
#define String1 char*
    typedef char* String2;
    String1 str1,str2;//宏替换 char* str1,str2;//str2只是一个字符变量，不是指针变量
    String2 str3,str4; //但是这个是这样，char *str3；char * str4;
  
    return 0;
}

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！
");
}
static void anotherOne()//只能在one.c中使用。内部函数
{
    printf("anotherOne is called！
");
}

主函数

#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 0;
}

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 = 12;
    }
     //在函数内部访问同名全局变量2
    int *p = &b1;
    
    int b1;
    b1 = 20;
      
    
    return 0;
}

int a;

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