学习日志

今日学习任务：

指针

日任务完成情况：

指针是C语言之最，当时学习这部分内容时掌握的便不是很好，现在拿出来又讲一边，还是有部分模糊的地方。

今日问题汇总：

遇到返回是指针时，总要纠结很久用什么带回。

今日开发收获：

对比复习了指针数组，数组指针等概念。

自我评价：

上课时有时会不耐烦，有点分心。

 

1.统计随机数的分布，产生10000个以上的10以内随机数，统计0~9出现的次数，保存在数组里。

 34 int main(int argc,char *argv[])
 35 {
 36     int i;
 37     int a[10]={0,0};
 38     for(i=0;i<10000;i++)
 39     {
 40        int rnum=rand()%10;
 41        for(i=0;i<10;i++)
 42        {
 43            if(rnum==i)
 44          a[i]++;
 45 
 46         }
 47     }
 48 //  a=count();
 49     for(i=0;i<10;i++)
 50     printf("%d\t%d\n",i,a[i]);
 51     return 0;
 52 }

2.编写字符串逆序函数，不借助于任何字符串函数,使用指针完成。

 

/*****************************************************************
  2 *   Copyright (C) 2018 SU_QIAN Ltd. All rights reserved.
  3 *   
  4 *   文件名称：nixu.c
  5 *   创 建 者：warning
  6 *   创建日期：2018年07月19日
  7 *   描    述:编写字符串逆序函数，不借助于任何字符串函数,使用指针完成。
  8 *
  9 *****************************************************************/
 10 #include <stdio.h>
 11 void reverse(char *a,int len)
 12 {
 13 char *p=NULL;
 14 char *q=NULL;
 15 p=a;
 16 q=a+len-1;
 17 while(p<q)
 18 {
 19 char temp=*p;
 20 *p=*q;
 21 *q=temp;
 22 p++;
 23 q--;
 24 }
 29 }

 33 int main(int argc,char *argv[])
 34 {
 35 int i;
 36     char a[6]={'h','e','l','l','o','\0'};
 37     reverse(a,6);
 38 //  printf("%s",a);
 39 for( i=0;i<6;i++)
 40 printf("%c",a[i]);
 41     return 0;
 42 }

5.用字符指针数组实现主程序的menu（）菜单。

 1 /*****************************************************************
  2 *   Copyright (C) 2018 SU_QIAN Ltd. All rights reserved.
  3 *   
  4 *   文件名称：menu.c
  5 *   创 建 者：warning
  6 *   创建日期：2018年07月19日
  7 *   描    述：用字符指针数组实现主程序的menu（）菜单.
  8 *
  9 *****************************************************************/
 10 
 11 
 12 #include <stdio.h>
 13 #include <stdlib.h>
 14 char *menu[]=
 15 {
 16 "*********************",\
 17 "**1.insert a resord**",\
 18 "**2.query a record **",\
 19 "**3.delete a record**",\
 20 "**0.quit           **",\
 21 "*********************"
 22 };
 23 
 24 char display_menu(char **menu,int len)
 25 {
 26     int i;
 27     char sel;
 28     while(1)
 29     {
 30     for(i=0;i<len;i++)
 31 {   printf("%s\n",*(menu+i));}
 32     printf("please input your choice");
 33     scanf("%c",&sel);
 34     if(sel>='0'&&sel<len-2+'0')
 35 {   return sel;}
 36     else
 37 {   printf("error");}
 38 
 39 
 40     }
 41 }
 42 int main(int argc,char *argv[])
 43 {
 44     display_menu(menu,6);
 45     return 0;
 46 }

6.函数指针的应用。

今日份笔记：

函数回顾、实例练习。
程序：1）交换函数swap，传值与传址的区别 2）封装使用动态库、静态库 3）递归函数 4）数组做实参传递时形参的定义和含义

指针：
1.指针定义与使用
2.指针运算
3.指针与数组（一维数组、二维数组）
4.多级指针（指针的指针） 
5.指针数组
6.字符串、字符指针数组
7.指针函数
8.函数指针
9.const与指针
10.void指针

1.指针定义与使用

sizeof(p)不管是指向什么类型的指针，它的sizeof（p）都是4，即4个字节（32位的地址）

int *p
char *p
float *p
struct NODE *p

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

 a=*p+1 取值，值加一
 a=++(*p) 取值，值加一
 a=(*p)++ 取值，值加一
 a= ++*p  取值，值加一
 a= ++(*p)取值，值加一

 a=*p++  取值，指针加一

 a=*++p 指针先加一,取值

 a=*(p+1) 指针先加一,取值

*(*(a+i)+j) == a[i][j]

指针与空值比较：
if( NULL == p )

void *malloc(size_t size);
void free(void *ptr);

对于返回指针的函数返回值一定要用if(p!=NULL)做判断，否则很有可能p指向一个未知的危险地址

***if(p) 危险（未初始化、初始化、释放后）if（p）条件都为真

指针变量未赋值时，可以是任意值，是不能使用的，会造成意外错误。而指针变量给NULL值后，则是可以使用的，只是不指向具体的变量。

定义一个指针时，最好初始化p=NULL;

2.指针运算
int *p，*q;
p++
p--
p+1   
p-1

p-q;
p>q;

以当前定义为例：
规则：1.指针做加1或者减1运算代表指向下一个int类型的数据或者前一个int类型的数据,指针指向的位置是当前地址加上sizeof(int),或者当前地址减去sizeof(int)
2.指针之间可以做减法运算，前提是两个指针类型一致，指向同一数据元素（比如指向同一数组）

减法的含义代表两个指针之间元素的个数;

3.指向同一数据元素（比如指向同一数组）指针可以比较大小，p>q;

 

3.指针与数组（一维数组、二维数组）
int a[10];
int *p=a;(int *p;  p=a;)

*(a+i), a[i], *(p+i), p[i]

int a[5][10]
int *p;
int (*q)[10];
p = &a[0][0];
q = &a[0];
*(*(q+i)+j) == a[i][j]

字符数组的值：
1.定义的同时初始化
2.输入函数scanf\gets\fgets
3.字符串函数strcpy

char a[]="hello world";
char *p=NULL;

p="today"; 对 把内存中“today”字符串常量的地址赋值给了p
a="today" 错

结论：指针是地址变量，而数组名是地址常量，数组名在运算中可以作为指针参与，但不允许被赋值，指针可变，允许指向别的位置

指针和数组常见等价操作：
指针操作    数组操作      说明
p            &a[0]        数组首地址
*p           a[0]         数组的第一个元素
p+i          &a[i]        数组的第i个元素的地址
*(p+i)        a[i]        数组的第i个元素
*p+b          a[0]+b      数组的第一个元素的值加b
*(p+i)+b      a[i]+b      数组的第i个元素的值加b

注：当前p指向第i个元素
*p++          a[i++]      先取得数组的第i个元素的值，i加1//先取得数组的第i个元素的值,指针p再加一，指向a[i+1]
*++p          a[++i]      先i加1，取得数组的第i+1个元素的值，//指针p先加一，指向a[i+1]，再取得数组的第i+1个元素的值 
*p--          a[i--]      先取得数组的第i个元素的值，i减1//先取得数组的第i个元素的值, 指针p再减一，指向a[i-1]
*--p          a[--i]      先i减1，取得数组的第i-1个元素的值，//指针p先减一，指向a[i-1]，再取得数组的第i-1个元素的值 

                        ，
二维数组：

行指针、列指针

&a[0][0] ==  a  值一样，含义不一样
&a[0][0]表示数组首地址，列地址
a表示数组首地址，行地址
地址和值：

&a[i][j]   &a[i][0]+j     a[i]+j      *(a+i)+j
a[i][j]   *(&a[i][0]+j)  *(a[i]+j)    *(*(a+i)+j)

4.多级指针（指针的指针）
int **p;
理论上多级指针最多可以到12级别，实际上2级指针用的多
main(int argc,char *argv[])  / main(int argc,char **argv)

5.指针数组
int *p[10];
char *a[20]; 
p是一个指针数组，数组的名字是p，数组有10个元素，每一个元素值都是一个指向整形数据的指针

注意事项： int (*p)[10]的区别，这是一个指针，指针的名字是p,指向一个含有10个元素的整形数组
int a[10];
int (*p)[10];
p=a;

指针数组的引用可以认为是一个指向指针的指针，因为数组名本身代表地址，可以做指针参与运算（不能改变其值）数组元素的值是指针，因此是二级指针，**p

6.字符串、字符指针数组

C语言本身没有字符串类型，用字符数组来表示字符串（约定最后一个字符是'\0'）；

char a[10]="Welcome";
char *s="Welcome";
s="hello";对
a="hello";错

初始化字符串指针时，实际是把内存中字符串的首地址赋值给指针变量，并不是复制字符串给指针，因为指针只占4个字节，用来保存一个地址

字符数组与字符串函数
#include <strings.h>
strcasecmp, strcat, strchr, strcmp,  strcpy,  strdup,  strlen,
strncat, strncmp, strncpy, strncasecmp,  strstr,  strtok

#include <stdlib.h>
atoi, atol, atoll, atoq - convert a string to an integer
strtod, strtof, strtold - convert ASCII string to floating-point number

字符型指针数组实现程序主菜单！！！！

7.指针函数
指针函数：若一个函数返回的是指针，则称该函数为指针函数。malloc/free

函数内部的变量都是局部变量，当函数执行完后，会自动释放，在主调函数中不能再访问，访问一段释放的内存，是非法操作，若修改非法内存中的值，可能会出现严重后果，不可预料。

解决方法：
1. 用static将局部变量变为静态局部变量
2. 字符串常量类似于静态变量，在程序结束时，才释放内存。函数中使用 char *str="Welcome"; "Welcome"是一个常量，在内存中有确定的地址，把这个地址返回给主调函数是可以的
3. 在堆空间分配内存，返回分配内存的地址给主调函数。str=(char *)malloc(20);
   注意：堆空间的使用一定要注意使用后要释放。 malloc / free 一定是对应的，如果不释放，指针已经指向其他地方，此空间成为内存泄漏空间。
 
8.函数指针
函数指针是一个专门用于保存函数首地址的指针，实际上就是函数的入口地址。
函数指针指向哪个函数，(*P)()就调用哪个函数。

int (*p)(int,int);
实例分析：call.c
输入字符串a+b 调用strsplit函数根据运算符+分割字符串，分割后保存在指针数组char *pstr[]; pstr[0]保存的是第一个操作数a的地址（此时仍当作字符串处理））pstr[1]保存的是第二个操作数b的地址（此时仍当作字符串处理）），使用atoi函数将字符串转换成整形数据，将q指向要调用的函数，调用operate(q,a,b)，就完成了相应的运算。

int(*p[10])(int,int) 函数指针数组

9.const与指针

const int *p;
int const *p;

int * const p;

区别：把数据类型去掉const int *p->const *p 说明*p是常量，即p指针指向的内存空间的整形值不允许更改
  把数据类型去掉int * const p-> * const p 说明指针p是常量，即p指针不能改变；
  3     int a=10,b=20;
  4     const int *p;
  5     int * const q=&b;
  6     p=&a;
  7     //*p=30;//非法
  8     p=&b;
  9     //q=&a;//非法
 10     *q=30;

10.void指针
void*
void指针不是空指针，而是一种不确定数据类型的指针，可以通过强制类型转换将void型指针转换为任何类型的指针。
举例：
void *malloc(size_t size);

char a[20]
a=(char *)malloc(sizeof(a));

int b[20]
b=(int *)malloc(sizeof(b));