001-C指针和函数指针

1. 指针变量

指针就是存放相同类型变量的地址的变量，用&符号获取某个类型变量的地址，然后赋值给对应数据类型的指针变量，对应数据类型后面加上*号标记该变量是指针变量。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main(int argc, const char * argv[]) {
    double a = 11111.22f;
    printf("a=%.1f\n", a);

    int i = 89;
    int *p = &i;
    double j = 78.9;
    //p = &j;
    printf("double size %d\n", sizeof(double));
    printf("%#x, %d\n", p, *p);
    return 0;
}

输出如下： 

a=11111.2
double size 8
0xefbff4d4, 89

2. 错误使用指针示例

int *k= NULL;
printf("%d\n", *k); // Bad Access Exception

3. 二级指针和多级指针

int b = 10;
int *pb = &b; // 一级指针 对整数获取地址并存放
int **ppb = &pb; // 二级指针 对一级指针变量获取地址并存放
int ***pppb = &ppb; // 三级指针 对二级指针变量获取地址并存放
printf("%#x, %#x, %#x\n", pb, ppb, pppb);

// 解指针
// *pb 获取的是一级指针指向的变量所存的值
// *ppb 获取的是二级指针指向的变量所存的值（即一级指针变量的地址）
// *pppb 获取的是三级指针所指向的变量所存的值 （即二级指针变量的地址）
printf("%d, %#x, %#x\n", *pb, *ppb, *pppb);

int qb = *pb;
int qqb = **ppb;
int qqqb = ***pppb;
printf("%d, %d, %d\n", qb, qqb, qqqb);

输出如下：

0xefbff4bc, 0xefbff4b0, 0xefbff4a8
10, 0xefbff4bc, 0xefbff4b0
10, 10, 10

4. 指针运算与数组

int arrays[] = {78, 90, 23, 56, 19};
// 数组变量名aray就是数组的地址，下面三个打印出来的地址是一样的
printf("%#x\n", arrays);
printf("%#x\n", &arrays);
printf("%#x\n", &arrays[0]);
// 指针变量
int *p_array = arrays;
// 获取到的是数组arrays中的第一个元素内容78
printf("%d\n", *p_array);
// 指针加法 +1 表示向前移动sizeof(数据类型)个字节，相当于直接
// 移动到数组的下一个index的地址
// 数组在内存中式连续存储的
p_array++;
printf("%d\n", *p_array);

输出如下：

0xefbff4d0
0xefbff4d0
0xefbff4d0
78
90

int uids[5];
// 高级写法
int index = 0;
for (int index=0; index< 5; index++){
    uids[index] = index;
}

// 循环输出uids元素
for (int l = 0; l<sizeof(uids)/sizeof(int); l++){
    printf("uids[%d] is %d\n", l, uids[l]);
}

// 早些版本的写法 p<uids+5 uids是下标为0的内存地址，
// +5 表示下标为index+5的内存地址
// p初始化值就是uids, p++直到循环结束
int *p_uids = uids;
int k = 0;
for (; p_uids < uids+5; p_uids++){
    *p_uids = k;
    k++;
}

输出如下：

uids[0] is 0
uids[1] is 1
uids[2] is 2
uids[3] is 3
uids[4] is 4

5. 获取整数数组最小元素

int* getMimumPointer(int ids[], int length){
    int *p = &ids[0];
    for (int index=0; index<length; index++){
         int id = ids[index];
         if (id<*p) {
             *p = id;
         }
    }
    return p;
}

// 初始化种子
srand((unsigned)time(NULL));
int ids[10];
for (int index=0; index< 10; index++){
    ids[index]=rand()%100;
    printf("%d ", ids[index]);
}
//
int *id = getMimumPointer(ids, 10);
printf("\n最小值地址是 %#x, 数值为 %d\n", id, *id);

输出如下：

67 2 41 1 49 53 79 2 8 55 
最小值地址是 0xefbff480, 数值为 1

6. 函数指针

// 函数指针
void message(char* title, char* content) {
    printf("MessageBox Title %s, Content %s\n",title, content);
}

//函数指针 void 是返回值类型， （*func_p）是函数指针名称 （）是函数参数列表
void(*func_p)();
func_p = message;
func_p("我是标题 ", "我是内容");

输出如下：

MessageBox Title 我是标题 , Content 我是内容

7. 动态内存分配

// 动态内存分配
//int array[1024*1024*10];

int *iP = malloc(1024*1024*10*sizeof(int));
getchar();
free(iP);

8. 字符数组操作

puts("!!!Hello World!!!"); /* prints !!!Hello World!!! */
getchar();
// 字符数组碰到\0表示字符数组结尾
char str[10] = {'H', 'e', 'l', 'o', '\0'};
// 字符数组清零
memset(str, 0, 10);
// str 字符数组被清空 长度为0 内容为空
printf("string length :%d and string is %s\n", strlen(str), str);

char sstr[] = "Hello world";
for (int i=0; i<strlen(sstr); i++){
    printf("[index:%d]%c\n", i, sstr[i]);
}

9. 字符串拼接

char * str ="hello";
char * str1 = "world";
const int DIST_LEN = 100;
char dist[DIST_LEN];
memset(dist, 0, 100);
strcat(dist, str);
strcat(dist, "123");
// 截取指定长度的字符串
strncat(dist, str1, 3);
puts(dist);

输出如下：

hello123wor