指针的使用

  • 交换变量
1
2
3
4
5
viod swap(int *p, int *q){
  int t = *p;
  *p = *q;
  *q = t;
}
  • 函数返回多个返回值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
viod minmax(int a[], int len, int *min, int *max){
  int i;
  *min = *max = a[0];
  for(i=1; i<len; i++){
    if(a[i]<*min){
      *min = a[i];
    }
    if(a[i]>*max){
      *max = a[i];
    }
  }  
}

int main(void){
  int a[] = {1,2,5,6,7,9,123,456,234,54,1234};
  int min,max;
  minmax(a, sizeof(a)/sizeof(a[0]), &min, &max);
}
  • 返回运算状态，结果通过指针返回
    通常是让函数返回特殊的不属于有效范围内的值来表示出错。（-1 0）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//函数指针
void f(void){
  printf("f 函数调用。\n");
}
void (*fun)() = f;
f();
(*fun)();

//示例
void (*fs[])(int) = {f,g,h,k};
if(i>=0; i< sizeof(fa)/sizeof(fa[0])){
  (*fa[i])(0);
}

//示例
int plus(int a, int b){
  return a+b;
}
int minus(int a, int b){
  return a-b;
}
void cal(int (*f)(int a, int b)){
  printf("%d\n", (*f)(2,5));
}
int main(){
  cal(plus);
  cal(minus);
  return 0;
}

指针变量必须有初始值，否则会报错。

指针和const

1
2
3
4
5
6
7
8
int i;
const int *p1 = &i;
int const *p2 = &i;
int *const p3 = &i;

// 表达的意思
const在*前面：p1,p2不能被修改
const在*后面：指针不能被修改

指针的计算

通常加的是 sizeof(类型)
指针+1：指向下一个地址
指针- 1：指向上一个地址
指针-指针：返回两个地址之间有多少个同一个类型的个数
*p++：取出p所指的数据来，同时指向下一个地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
char ac[] = {0,1,2,3,4,5};
char *p = ac;
printf("p  =%p\n", p);
printf("p+1=%p\n", p+1);

// 输出结果
// p   = 0xbffbad5a;
// p+1 = 0xbffbad5b;

int ai[] = {0,1,2,3,4,5};
int *q = ai;
printf("q  =%p\n", q);
printf("q+1=%p\n", q+1);

// 输出结果
// q   = 0xbffbad2c;
// q+1 = 0xbffbad30;

while(*p != -1){
  printf("%d\n", *p++);
}

0地址

0地址通常不能碰的地址
指针不应该有0值
特殊意义：返回的指针无效；指针没有真正初始化；
NULL：预定义符号，表示0地址
有些编译器不愿意你用0表示0地址

指向不同类型的指针不能互相赋值

void*

直接访问内存地址，不确定什么类型

动态内存分配

int a = (int) malloc (nsizeof(int));
申请的空间大小以字节为单位，返回结果是void,需要类型转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <stdlib.h>

int main(void){
  int number;
  int *a;
  printf("输入数量：");
  scanf("%d", &number);
  
  a = (int*) malloc (number*sizeof(int));
  for(i=0; i<number; i++){
    scanf("%d", &a[i]);
  }
  for(i=number-1; i>=0; i--){
    printf("%d", a[i]);
  }
  
  //空间归还系统，归还的必须是申请的那个空间
  free(a);

  //能申请的最大空间
  void *p;
  int cnt = 0;
  while(p = malloc(100*1024*1024)){
    cnt ++;
  }
  printf("分配了%d00MB的空间\n", cnt);

  return 0;
}

字符串操作

putchar()
getchar()

EOF 返回 -1

字符串数组

char *a[];
char a[][10];
1
2
3
4
5
6
int main(int argc, char const *argv[]){
  int i;
  for(i=0; i<argc; i++){
    printf("%d:%s\n", i, argv[i]);
  }
}

busybox