学习日志以及个人总结（14）

    gets puts strlen 
    strcmp/strcnmp
    strcat/strncat
    strcmp/strncmp

strlen

   int Str_len(char *s)
   {
       char *i =s;                                                   
       while(*s != '\0')
       {
           ++s;
       }
      return s-i;
  }

strcmp

  int Str_cmp(char *s1,char *s2)
 {
      int ret =0;
     while(*s1==*s2)
      {
          ++s1;++s2;
          if(*s1==0 && *s2 ==0)
          {
             break;
          }
      }
          ret= *s1-*s2;

strncmp

 53 int Strncmp(const char *s1,const char *s2,int n)
 54 {
 55     while(n--&& (*s1==*s2))
 56     {
 57         if(n==0)
 58         {
 59             return 0;
 60         }
 61         s1++;s2++;
 62     }
 63     return *s1-*s2;
 64 }

strcpy

 94 char *Str_cpy(char *s1,char *s2)
 95 {
 96     while(*s1 = *s2)
 97     {
 98         s1++;
 99         s2++;
100     }
101     return s1;                                              
102 }

strncpy

 80 char *Strncpy(char *s1,const char *s2,int n)
 81 {
 82     while(n &&(*s1 = *s2))
 83     {
 84         s1++;s2++;
 85         --n;
 86     }   
 87         while(n)
 88     {
 89         --n;
 90         *s1++ = '\0'; 
 91     }   
 92     return s1;
 93 }

strcat

 41 char* Str_cat(char *s1,const char *s2)
 42 {
 43     while(*s1 != '\0')
 44     {
 45         ++s1;
 46     }
 47     while(*s1=*s2)
 48     {
 49         ++s1;                                               
 50         ++s2;
 51     }
 52 }

strncat

 25 char *Strncat(char *s1,const char *s2,int n)
 26 {
 27     while(*s1 !='\0')
 28     {
 29         ++s1;
 30     }
 31     while(n&&*s2 !='\0')
 32     {
 33         *s1=*s2;
 34         s1++;
 35         s2++;
 36         --n;
 37     }
 38     *s1 ='\0';
 39 }

指针 ＋函数

char * strcpy(); //返回值类型 --- 指针类型 --- 指针的函数 --指针函数
char * strcat();

回调函数

callback
 
 int funcN() //项目经理写的 
 {
 }
 
 main() //项目经理
 {
    choiceSortN(,funcN); //程序员 
 }
 
 回调函数: 通过函数指针调用的函数 叫回调函数 
 
 技术上: 通过函数指针的实现 
 
 函数指针(指向基类型-为函数类型) 函数类型的指针 
 
 接口 
 
  void qsort(void *base, size_t nmemb, size_t size,int (*compar)(const void *, const void *));
  
  @base    数组起始位置
  @nmemb   排序的元素个数 
  @size    单个元素的大小 
  @compar  比较函数  //确定进行比较的两个元素的大小规则 
  
  
  int a[10] = {1,2,3,4};
  
  int compar(const void *a, const void *b)  //回调函数
  {
     *(const int *)a - *(const int *)b     
  }
  compar 两个参数 其实表示 数组中某两个元素的地址 
  
  compar 返回值 表示的就是数组中两个元素的大小关系 
  
void *  //万能指针  --可以接收任意类型的指针 
        //void类型 
        //
        
        注意: 
         如果通过该类型的地址进行数据访问
         一定要转换为 明确类型 

小结：

1.指针 操作 函数 
2.函数名 就是函数的入口地址 
3.定义一个 函数指针变量 获得 函数名 
4.使用 
  通过指针变量的方式 进行函数调用 
5.用途 
  回调 

some 练习

qsort的实现（回调函数）

  1 #include
  2 #include
  3 #include
  4 int compar(const void *a,const void *b)
  5 {
  6     return strcmp((const char *)a , (const char *)b);       
  7 }
  8 
  9 int main(void)
 10 {
 11     char s[3][100]={"hello","world","china"};
 12     int len=sizeof(s)/sizeof(s[0]);
 13     qsort(s,len,sizeof(s[0]),compar);
 14     for(int i=0;i

写一个程序 实现加，减，乘，除
以回调函数的形式，打印对应的结果 

1 #include                                                                                                                                                                                       
  2 #include
  3 int add(int a,int b)
  4 {
  5     return a+b;
  6 }
  7 int sub(int a,int b)
  8 {
  9     return a-b;
 10 }
 11 int mul(int a,int b)
 12 {
 13     return a*b;
 14 }
 15 int ww(int a,int b)
 16 {
 17     return a/b;
 18 }
 19 
 20 void processData(int a,int b, int(*pfunc)(int,int))
 21 {
 22     printf("result:%d\n",pfunc(a,b));
 23 }
 24 
 25 int main(void)
 26 {
 27     int a=0;int b=0;
 28     char c;
 29     printf("input a num:");
 30     scanf("%d%c%d",&a,&c,&b);
 31     switch(c)
 32     {
 33     case'+':
 34         processData(a,b,add);
 35         break;
 36     case'-':
 37         processData(a,b,sub);
 38         break;
 39     case'*':
 40         processData(a,b,mul);
 41         break;
 42     case'/':
 43         processData(a,b,ww);
 44         break;
 45     }
 46     return 0;
 47 }                  

指针＋二维数组

int a[3][4]; //本质还是一维数组 
int[4] a[3]; //理解角度 
             //a --数组名 --代表类型 int [3][4]
             //a --代表的值 -- 首元素的地址 -- a[0] 
             //a[0] 的数据类型 int[4]
             //&a[0]--对应的数据类型 int(*)[4] //数组类型 (一维整型数组类型)
             //数组类型的指针 --- 数组指针                   
             int *
             
int (*p)[4] = a;

*p   //三步运算完成后
     *p 相当于 是 int[4]这种类型 //数组
     *p 就相当于 int[4]这个数组的 数组名

int a = 10;
int *p = &a;

*p <=> a     

*(*(p+i) + j)<=>a[i][j]

p+1 //偏移到了 下一个 int[4]
    //类型为int(*)[4]
*(p+1) //偏移到下一个int 
       //*(p+1) 代表的类型int[4] 此时相当于是 int[4]的数组名 
       //*(*(p+1) + 1)