【Objective-C】01-学习iOS开发前期知识积累之C语言知识大总结

第一章 C语言概述
C语言的特点
语言简洁，紧凑，使用方便，灵活。
运算符丰富。
数据类型丰富。
具有控制语句（if...else.. while..switch...cese...for）。
语法限制不太严格。
C语言允许直接访问无力地址，能进行位操作，能实现汇编语言的大部分功能，可以直接进行操作。
声称目标代码质量高，执行程序效率高。
用C语言编写的程序可移植性好。
简单的c语言程序

每个函数都必须要有一个main函数，main是函数的名字，表示主函数，main前面的Int表示此函数执行后返回一个整型值。函数体用花括号{}括起来。’\n’为换行符，即在输出C语言后换行。如果函数有返回值，我们用return关键字返回结果，此程序返回的整型数为0.
另外在写程序时一定要注意中英文的书写，如果不小心很可能导致程序出错。
第二章 C语言数据类型、运算符和表达式
C语言的数据类型
C语言包括的数据类型有：整型（short int、int、long int）;实型(float、double、longdouble)，字符型（char）和枚举类型。
常量
整型常量有指数形式，一个实数的指数形式分为尾数部分和指数部分。尾数部分可以是整数行书或小数形式，指数部分是一个字母“e”后跟一个整数。其中“e”前面必须有数字，“e”后面必须是整数。

在c语言中，字符型类型用于表示一个字符值，但字符类型的内部表示是字符的ASCll代码，并非字符本身。

特别值得主意的是字符常量一定要用单引号（‘’）括起来
字符串常量是用一对双引号(“”)括起来的字符序列.
其中有一些转义字符：\n （换行） \t （水平指标） \b （退格） \r（回车） \f（换页） \\（代表反斜杠）   \’（代表单引号）   \”（代表双引号）   \ddd （1到3位八进制代表字符） \xhh（1到2位十六进制代表的字符）
变量
变量的定义形式：
基本变量类型有char（字符型）、int（整型）、float、double（实型）、void（无值型第一是明确地表示一个函数不返回任何值，第二是产生一个通用类型的指针）。
类型     变量名表       例如     int a;   float b; char c;
在书写变量说明时要注意：
允许在一个类型说明符后，说明多个类型的变量。各变量名用逗号隔开。类型说明符与变量名之间至少用一个空格间隔
最后一个变量名之后要以“:”结尾。
变量说明必须放在变量使用之前。一般放在函数体的开头部分。
控制台赋值：&取地址符
char ch; scanf(%c,&ch);     int a;   scanf(“%d”,&a);   float   b;scanf(%f,&b);
尤其要注意给控制台的时候   一定要加取地址符！
类型转化
显式类型转化
（类型说明符）（表达式）例如（float）a 就是把a转换为实行   （int）（x+y）就是把x+y的结果转换为整型
在强制转换时要注意以下几点
类型说明符和表达式的都必须加括号（单个变量可以不加括号），如把（int）（x+y）写成（int）x+y则成了把x转换成int型之后在于y相加了
无论是强制转换或是隐式转换，都只是为了本次运算的需要而对变量的数据长度进行的临时性转换，而不改变数据说明时对该变量定义的类型
隐式转换
隐式转换发生在不同数据类型的量混合运算时，由编译系统自动完成。自动转换遵循以下规则
若参与运算量的类型不痛，则先转换成同一类型，然后进行运算。
转换按数据长度增加的方向进行，以保证精度不降低，如int型和long型运算时，先把int转换成long型后在进行运算。
所有的浮点运算都是以双精度进行的，即使仅含float单精度运算的表达式，也要先转换成double型，在运算
char型和short型参与运算时，必须先转换成int型。
在赋值运算中。赋值号两边量的数据类型不同时，赋值号右边的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。下图为自动转换规则
                                                             
                                                               double                                                    float
                             
                                                                       long



                                                       unsigned



                                                                         int     

                                                                                                                                                   char


运算符和表达式
运算符
算数运算符包括：加（+）、减（-）、乘（*）、除（/）、取余（或称为模运算，%）、自增（++）、自减（--）。
关系运算符：大于（>）、小于(<)、等于(=)、大于等于(>=)、小于等于(<=)、和不等于(!=)
逻辑运算符：&&（与）、或（||）、非（！）
位操作运算符：位与（&）、位或（|）、位非（~）、位异或（^）、左移（<<）、右移（>>）.
赋值运算符：简单赋值（=）、复合赋值（+=，-=,*=,/=,%=）和复合运算赋值（&=,|=,^=,>>=,<<=）.
条件运算符：三目运算符用于条件求值（?   :）.
逗号运算符：用于把若干表达式组合成一个表达式（，）。
指针运算符：用于取内容（*）和（&）二种运算。
求字节运算符：用于计算数据类型所占的字节数（size of）.
特殊运算符：有括号(),下标[],等几种
其中需要注意的是++，--和?   :
i++     i--   i参与运算后，i的值在自增（减）1.
++i   --i     i参与运算前，i的值自增（减）1.
#import

int main(int argc, const char * argv[])
{

       @autoreleasepool {
             
               int i=8;
               printf("%d\n%d\n%d\n%d\n",++i,--i,i++,i--);//输出结果9 8 8 9     第一个i先++所以输出9，这时i的值为9 第二个--i所以的i值为8   第三个i++所以第三个i输出也是8 第四个i是9因为第三个i++，这时在输出i为8因为第四个i--
       }
       return 0;
}
?   : 是具有三个操作数的运算符，表达形式
表达式1?表达式2:表达式3
含义为：先求表达式1的直如果为真（非零），则求表达式2的值，并把它作为整个表达式的值，如果表达式为假（0），则求表达式3的值，并把它作为整个表达式的值
#include

int main(int argc, const char * argv[])
{
       int a=10,b=5,c=6,d=0;                                 
       d = ((a+b)*(c-b)/(c%4))+a++;
       printf("d is%d",d);
       printf("%d",a);
       return 0;
}
#include

int main(int argc, const char * argv[])
{
       int a=10,b=9;
       int c=a & b;
       int d=a|b;
       char str[]="hello";
       printf("sizeof(a) = %ld\n",sizeof(a));//获取int类型的长度
       printf("sizeof(str)=%ld\n",sizeof(str));//获取字符数组的长度注意结束符号   应该是6
       printf("a&b =%d\n",c);//电脑是转换成2进制进行运算
       printf("a|b =%d\n",d);
       printf("a左移一位： %d\n",a<<1);
       printf("a / b=%d",a/b);
     

}

第三章 分支循环
分支
if(表达式)语句
if（a>b）printf(“%d”,a);
2 if(表达式)语句1 else语句2
if(x>y)
printf(“%d”,x);
else
printf(“%d”,y);
3 if(表达式1)语句1
else if(表达式2)语句2
else if（表达式3)语句3
else if (表达式4)语句4
..........
另外if大括号不用加分号
#import

int main(int argc, const char * argv[])
{

       @autoreleasepool {
             
               char c1 = 0;
               printf("请输入字符");
               scanf("%c",&c1);
               if (c1<='9'&&c1>='0')
               {
                       printf("输入的是数字");
               }
               else if (c1>='A'&&c1<='Z')
               {
                       printf("你输入的是大写字母");
                     
               }
               else if (c1>='a'&&c1<='z')
               {
                       printf("你输入的是小写字母");
               }
               else
               {
                       printf("你输入的是其他字符");
               }
       }
       return 0;
}
if   语句的嵌套
if()
   if()语句1
   else语句2
else
   if()语句3
   else语句4
#import

int main(int argc, const char * argv[])
{

       @autoreleasepool {
               int a,b;
             
               printf("请输入2个数(用空格隔开)");
               scanf("%d%d",&a,&b);
               if (a==b) {
                       printf("输入的2数相等");
               }
               else
               {
                       if (a>b)
                       {
                               printf("a>b");
                       }
                       else
                       {
                               printf("a
            }
        }
    }
    return 0;
}
?  : 是具有三个操作数的运算符，表达形式
表达式1?表达式2:表达式3
含义为：先求表达式1的直如果为真（非零），则求表达式2的值，并把它作为整个表达式的值，如果表达式为假（0），则求表达式3的值，并把它作为整个表达式的值
这里要说一下这个  跟if  else  有点像
#import

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        //判断2数大小
        int a,b;
        scanf("%d%d",&a,&b);
       
        printf("%d",(a>b)?a:b);
       
    }
    return 0;
}

switch语句
switch(表达式)
｛
    case常量表达式1:语句1
    break;
    case常量表达式2:语句2
    break;
    ....
    default:语句n
    break;   
｝
尤其要注意加 break；break跳出循环，继续执行switch语句下面的语句。如果不加break会把下面的也给输出出来。
break语句不能用于循环语句和switch之外的任何语句中。
continue语句作用是结束本次循环，即跳出循环体中下面尚未执行的语句，接着惊醒下一次是否执行循环的判断。
continue和break的区别是：continue语句只是结束本次循环，而不是终止整个循环的执行。而break语句是结束整个循环过程，不在判断执行循环的条件是否成立。
int main(int argc, const char * argv[])
{

    @autoreleasepool {
        int a,c;
        char b;
       
        printf("请输入a+（-*/）b\n");
        scanf("%d%c%d",&a,&b,&c);
        switch (b) {
            case '+':
                printf("%d",a+c);
                break;
            case '-':
                printf("%d",a-c);
                break;
            case '*':
                printf("%d",a*c);
                break;
           
            case '/':
                printf("%d",a/c);
                break;
               
            default:
                printf("输入有误");
                break;
        }
       
    }
    return 0;
}
使用switch语句要注意以下几点：
在case后的各常量表达式的值不能相同，否则会出现错误
在case后，允许有多个语句，用{}括起来
在各case和default句子的先后顺序可以改变，而不会影响程序执行结果。
default句子可以省略不用
循环
while（表达式）语句
#import

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        int i=1,sum=0;
       
        while (i<=100) {//循环条件，当i>100时跳出循环
            sum+=i;//
            i++;
        }
        printf("%d",sum);
       
    }
    return 0;
}
注意：1循环体如果包含一个以上语句，应该用花括号括起来，以复合语句出现。
如果不加花括号，则while语句范围只到while后面第一个分号处，例如上例，只能到sum+=i
2循环体要有使循环体趋向结束的语句。例如上例循环结束语句i>100，应要有导致i>100的语句。如果没有 会造成死循环
do   while 循环语句
do
    循环体语句
while（表达式）；
while与do while 区别在于while是当条件满足时才执行循环体，do   while 是先执行循环体，后判断表达式的“当型”循环。
for循环
for（循环变量赋初值;循环条件;循环变量增值）
#import

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        int  sum;
       
        for (int i=0; i<=100; i++) {
            sum+=i;
           
        }
        printf("%d",sum);
       
    }
    return 0;
}
for循环也可以改写成while循环形式
表达式1；
while表达式2
｛
    语句
    表达式3
｝
int main(int argc, const char * argv[])
{

    @autoreleasepool {
        int i=1,sum=0;
       
        while (i<=100) {//循环条件，当i>100时跳出循环
            sum+=i;//
            i++;
        }
        printf("%d",sum);
       
    }
    return 0;
}
#import

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        int a,b=1;
        for (a=0; a<5; a++) {
            for (b=5; b>a; b--) {
                printf(" ");
            }
            for (b=0; b
                printf("* ");
            }
            printf("\n");
        }
      
       for(int j=0;j<=5;j++)
           {
          for (int x=5; x>j; x--) {
                printf("* ");
            }
           printf("\n");
               for (int x=0; x
               {
                   printf(" ");
               }
            
          }
        }
       
      
  
    return 0;
}
关于杨辉三角

100内素数
#import

int main(int argc, const char * argv[])
{

   
//求100以内所有素数
        int i=0;
        for (int n=2; n<100; n++)//能够得到2到100之内的数
        {
            for (i=2; i
            {
                if (n%i==0)//条件语句，能被整除
               
                    break;//结束这次循环
               
               
               
            }
            if (i>=n)//条件语句假如除数等于被除数
            {
                printf("%d ",n);//输出除数
            }
           
       
           
        }
   
       
      
  
    return 0;
}
#import

int main(int argc, const char * argv[])
//猴子吃桃问题
{

    @autoreleasepool {
        int a;
        for (int i=0; i<10; i++) {//吃的天数
            a=(a+1)*2;//  倒数第二天剩余6个，吃一半剩3个，在吃一个剩2个， 倒数第一天吃一半剩余1个，在吃一个剩余0个，
        }
        printf("%d",a);

       
    }
       
    return 0;
}
#import

int main(int argc, const char * argv[])
//找出数组中重复的数
{

    @autoreleasepool {
        int a[10]={1,2,3,4,5,5,6,7,8,9};
        for (int i=0; i<9; i++)
        {
            if (a[i]==a[i+1])//注意程序中的‘==’才等于‘=’
            {
                printf("%d ",a[i]);
               
            }
        }
       

       
    }
       
    return 0;
}
第四章函数 数组  结构体
函数
库函数：由C系统提供，用户无需顶峰一，也不必在程序中作类型说明，只需在程序前包含有该函数原型的头文件即可在程序中直接调用。例如printf、scanf、getchar、putchar、gets、puts、strcat等
用户定义函数：由用户按需要写的函数。又分有返回值和无返回值
从主调函数和被调函数又分有参函数和无参函数两种
函数的声明与定义
函数的声明，标准编译器，对函数的调用，都要先声明才能调用
有参函数定义的一般形式
类型标示符 函数名（形参列表）
｛
      声明部分
    语句部分   
｝
#import
void max(int a,int b)
{
   
    if (a>b) {
        printf("%d",a);
    }
    else
        printf("%d",b);
}

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        int a,b;
        scanf("%d%d",&a,&b);
        max(a,b);//调用函数
       

       
    }
       
    return 0;
}
数组
一维数组的定义
类型说明符  数组名[常量表达式]
int a[10];
一维数组的引用
数组的定义必须要有大小   int a[ 3]={1,2,3};
数组只能存放一种类型
数组的元素用下标表示
数组下标从0开始   int a[0]   int a[1]


#import


int main(int argc, const char * argv[])
//将10个数导入数组中
{

    @autoreleasepool {
        int a[10];
        printf("请输入10个数");
        for (int i=0; i<10; i++) {
            scanf("%d",&a[i]);
        }
        for (int j=0; j<10; j++) {
            printf("%d",a[j]);
        }


       
    }
       
    return 0;
}
冒泡排序
#import
void paixu(int a[],int n)
{
    for (int i=0; i
        for (int j=0; j
            if (a[j]>a[j+1]) {//实现两两交换
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
}


int main(int argc, const char * argv[])

{

    @autoreleasepool {
        int a[]={};//定义一个数组
        printf("请输入10个数");
        for (int i=0; i<10; i++)
        {
            scanf("%d",&a[i]);//向数组中输入数
        }
        paixu(a, 10);//调用函数
        for (int j=0; j<10; j++) {
            printf("%d",a[j]);
        }


       
    }
       
    return 0;
}
二维数组的定义
类型说明符  数组名 [常量表达式][常量表达式]
#import



int main(int argc, const char * argv[])

{
//穷举法  找最大数
    @autoreleasepool {
        int hang,lie,max;
        int a[3][4]={{1,2,3,15},{7,8,9,55},{10,25,99,100}};//定义2维数组
        max=a[0][0];
        for (int i=1; i<=3; i++) {//行进行3次比较
            for (int j=1; j<=4; j++) {//列进行4次比较
                if (max
                    max=a[i][j];//把大的赋予max
                    hang=i+1;//找到行数
                    lie=j+1;//找到列数
                }
            }
        }
        printf("最大数=%d在%d行在%d列",max,hang,lie);     
    }
       
    return 0;
}
结构体
struct  结构体名
｛
    成员列表；
   
｝变量名表列;
结构体数组
当输入的时候注意是（&结构体数组名.成员列表）
typedef struct student stu;//宏定义变量（创建结构体时可以用stu）
#import
struct student{//定义结构体
    int num;
    char name[20];
    char sex;
    int score;
   
   
   
   
};



int main(int argc, const char * argv[])

{

    @autoreleasepool {
        stu a[5];//创建结构体数组
        for (int i=0; i<5; i++) {//进行5次循环，输入5组数据
            printf("请输入学号");
            scanf("%d",&a[i].num);//输入学号
            printf("请输入姓名");
            scanf("%s",a[i].name);//字符串不用加取地址符
            printf("输入性别");
            scanf("%c",&a[i].sex);//输入学号
            scanf("%c",&a[i].sex);//如果不多打一个 会把也当作字符
            printf("请输入成绩");
            scanf("%d",&a[i].score);//输入学号
        }
        for (int j=0; j<5; j++)
        {
            printf("%d%s%c%d",a[j].num,a[j].name,a[j].sex,a[j].score);
        }
       
       
       
    }
    return 0;
}
写一个结构体变量，包括年月日，计算该日是本年的第几天，注意闰年问题
#import
struct date{//定义一个结构体
    int year;
    int month;
    int days;
};

int main(int argc, const char * argv[])

{

    @autoreleasepool {
        struct date input;
        int sum;//总天数
       
        int a[12]={31,28,31,30,31,30,31,31,30,31,30,31 };//定义一个数组包含每个月的天数，用来对应后面计算多少天
        printf("请输入年月日（比如2012 10 9）");
        scanf("%d%d%d",&input.year,&input.month,&input.days);//输入年月日储存到结构体理
        if (input.year@0==0||(input.year%4==0&&input.year0!=0))
        {//判断是否闰年
           
            if (input.month>=2)//判断月份是否大于2月
            {
                for (int i=0; i
                {
                    sum+=a[i];//加上每个月的天数
                }
                sum+=1;//因为是闰年 所以多加1
               
            }
        sum+=input.days;//在加上自己输入的天数
        }
        else
        {
            if (input.month>=2)
            {
                for (int i=0; i
                {
                    sum+=a[i];
                }
               
            }
            sum+=input.days;
        }
       
        printf("%d",sum);
       
       
       
    }
    return 0;
}
在升序数组中插入一个数，并且保持该数组仍为升序数组的函数
#import
//进行冒泡排序
void sort(int a[],int n)
{
    for (int i=0; i
        for (int j=0; j
            if (a[j]>a[j+1]) {
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
               
            }
           
        }
    }
}

int main(int argc, const char * argv[])

{

    @autoreleasepool {
        int a[6]={0,7,3,5,2,INT32_MAX};//定义一个数组
        int input;//定义要输入的数
        int in;//定义要插的位置
       
        sort(a, 6);//调用函数 进行冒泡排序
        printf("请输入要插入的数");
        scanf("%d",&input);
        for (int j=0; j<5; j++) {//循环5次
            if (input
                in=j;//把要插入的位置的数赋给要插的位置in
                for (int i=5; i>in; i--)//移动位置 从大到小开始移动（i=5）另外i要大于前面不需要排列的数所以i>in
                {
                    a[i]=a[i-1];//实现移位
                }
                a[in]=input;//把插入的值赋给要插入的位置
                break;//结束循环
            }
           
           
        }
        for (int i=0; i<6; i++) {
            printf("%d",a[i]);//输出数组
        }
       
       
       
    }
    return 0;
}
第五章 指针
指针就是一个地址，而指针变量就是存放地址的变量
类型 *名称[=地址]
直接访问：已知变量a，根据此地址直接对变量a的储存单元进行存取访问
间接访问：不知道a的地址，但是我们知道b中储存了a的地址，我们先访问b，取到a的地址后，再去访问a

int *a;
1定义上代表指针
2内容指的是对象的内容
如何确定指针所指向的类型
char *a 是指向char型变量的指针变量
int *a是指向int型变量的指针变量
#import
int changeValue2(int x,int y)
{
    int temp=0;
    temp=x+y;
    return temp;
}
void changeValue1(int *x,int *y)
{
    int temp = 0;
    temp = *x;
    *x = *y;
    *y = temp;
}
void changeValue3(int x,int y)
{
    int temp=0;
    temp=x;
    x=y;
    y=temp;
   
}
int main(int argc, const char * argv[])
{
   
    @autoreleasepool {
        int a=10;
        int b=20;
        //changeValue2(a,b)
        //printf("%d%d",a,b);
        changeValue3(a,b);//不能交换ab的值
        printf("%d %d\n",a,b);
       
        changeValue1(&a,&b);
        printf("%d %d ",a,b);
       
       

    }
    return 0;
}
数组与指针
通过指针引用数组元素
如果p的初值指向&a[0]
p+i和a+i就是a[i]的地址，或者说他们指向a数组的第i个元素
*(p+i)h或*(a+i)是p+i或a+i所指向的数组元素，即a[i]例如*(p+5)或*(a+5)就是a[5],即*(p+5)  *(a+5)  a[5]三者等价。在编译时实际是a[i]就是按照*(a+i)处理的可以看出[]实际上时变址运算符
指向数组的指针变量就是也可以带下标 如p[i]与*(p+i)等价
根据以上所述引用一个数组元素 可以用：
下表法，如a[i]形式
指针法，如*(a+i)或者*(p+i)，其中a是数组名，p是指向数组元素的指针变量其初值p=a
#import
void paixu(int *p,int n)
{
    int temp;
    for (int i=0; i
        for (int j=0; j
            if (p[j]>p[j+1]) {
                temp=p[j];
                p[j]=p[j+1];
                p[j+1]=temp;
            }
        }
    }
}


int main(int argc, const char * argv[])
{

    @autoreleasepool {
        int a[10]={0};//定义数组
       
       
        printf("请输入数");
        for (int i=0; i<10; i++) {//给数组赋值
            scanf("%d",&a[i]);
        }
        int *p=a;//定义整型指针指向数组a的首地址
        paixu(p, 10);//调用函数
        for (int j=0; j<10; j++,p++) {
            printf("%d",*p);//输出数组
        }
       
       
       
    }
    return 0;
}
指针数组  数组全是指针   数组指针  指向数组的指针
允许对指针进行运算操作 运算是基于数组指针才可以的
//字符指针
        char *str="hello";
        printf("%c\n",*str);
        printf("%c\n",*++str);
        printf("%c\n",*str+4);
        printf("%c\n",*(str+3));//注意加括号
数组不能进行运算  指针可以进行运算
数组的地址是常量
#import
void paixu(char *p[],int n)//因为是数组形参 也要是数组
{
    char *temp;
    for (int i=0; i
        for (int j=0; j
            if (strcmp(p[j], p[j+1])<0) {//比较字符串的大小用strcmp函数，因为是指针数组，包含三个指针，所以p[j]相当与指针数组的首地址，所以得用指针来接首地址 所以要定义指针temp
                temp=p[j];
                p[j]=p[j+1];
                p[j+1]=temp;
            }
        }
    }
}


int main(int argc, const char * argv[])
{

    @autoreleasepool {
        char *str[3]={"red","yellow","blue"};//定义一个指针数组
        paixu(str, 3);//调用
        for (int i=0; i<3; i++) {
            printf("%s",str[i]);//输出指针数组
        }
       
       
       
       
    }
    return 0;
}
#import
void paixu(int *p,int n)
{
    int temp;
   
   
    for (int i=0; i
        for (int j=0; j
            if (p[j]

                temp=p[j];
                p[j]=p[j+1];
                p[j+1]=temp;
            }
        }
    }
   
}

int main(int argc, const char * argv[])
{

    @autoreleasepool {
       
        int a[3]={3,1,9};//定义一个数组；
        int *p=a;//当把数组地址赋予指针时，不用加取地址符。
       
       
        paixu(p,3);
       
       
        for (int i=0; i<3; i++)
        {
                printf("%d",*p++);
        }
       
       
       
    }
   
}

指针与结构体
结构体指针
struct student{
 int num;
}
struct student *p;
p->num=10//给指针指向的NUM赋值

#import
typedef struct student
{
    char sex;
    int num;
    char *name;
}stu;//结构体定义及类型重定义  typedef struct student stu 相同作用

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        //指针与结构体
       
        stu s2;//声明结构体变量
        stu *p2;//声明指针指向stu类型的内容
        p2=&s2;
        s2.sex='m';
        s2.num=1;
        s2.name="hello";
        printf("性别%c 学号%d 姓名%s\n",s2.sex,s2.num,s2.name);
        p2->sex='f';
        printf("性别%c 学号%d 姓名%s\n",s2.sex,s2.num,s2.name);
        p2->name="word";
        printf("性别%c 学号%d 姓名%s\n",s2.sex,s2.num,s2.name);
指针高级
指针的指针
int a=10,b=20;                        地址2000(内容10)    2500 (20)
int *p=&a,*q=&b                3000(2000 )   3500(2500)
（int *）*m=&p,**n=&q           4000(3000)   4500(3500)
**m=10   *m=3000     **n=20   *n=3500  
#import
int main(int argc, const char * argv[])
{

    @autoreleasepool {
     int a=10,b=50;
            int *p=&a,*q=&b;
            int **m=&p,**n=&q;
            printf("%p\n",p);
            printf("**m=%d *p=%d a=%d *m=%p\n",**m,*p,a,*m);
            printf("%p\n",q);
            printf("**n=%d *q=%d b=%d *n=%p\n",**n,*q,b,*n);
            **m=30;
            printf("%d",a);
       
       
        }
        return 0;
    }
宏定义
用一个制定的标识符（即名字）来代表一个字符串
不带参数
#define  标识符  字符串
#define   PI  3.1415926
带参数
#define 标识符（参数表）字符串
#define LEAP(A) if(A@0==0||(A%4==0&&A0!=0)){printf("100");}
#define FENZHONG (365*24*60)
#define MAX1(A,B) (A>B)?A:B
注意 标识符 最好大写
用typedef命名已有类型
typedef struct student ss;//宏定义变量

#import
//结构体定义
struct student {//定义学生结构体
   
    char name[10];//姓名
    double result;//C语言成绩
    char sex;//性别
    int age;//年龄
   
   
   
};
枚举
枚举 是指将变量的值一一列表出来，变量的值只限于列表出来的值的范围
static
#import
int fac(int n)
{
    static int f=1;
    f=f*n;
    return f;
                                                                                                     
}

int main(int argc, const char * argv[])
{
   
    @autoreleasepool {
        int i;
        for (i=1; i<5; i++) {
            printf("%d\n",fac(i));
        }
        //每次调用fac（i），输出一个i！，同时保留这个i!,同时保留这个i!得值以便下次在乘（i+1）
        //如果初始化后，变量只被引用而不改变其值，则这时用静态局部变量比较方便，以免每次调用后 重新赋值
       
       
       
       

    }
    return 0;
}
const
1 const int *a   指向长整型数的指针 可以改地址 10不能动（内容不能动）
2 int const *a   指向整型数的常指针 可以改内容 不能动地址

随机产生数

c随机产生数
rand()%（y-x+1）+x


strcpy和strcmp
strcpy（a1,a2）是把a2拷贝给a1
strcmp(a1,a2)   比较2字符串的大小
a1>a2     返回值大于0
a1=a2     返回值等于0
a1
开辟空间
int *s；
s=malloc（size of(int )*40）返回地址为开辟空间的首地址
free(s)//释放