回调函数 _0302

#Makefile

src = $(wildcard *.c)
targets = $(patsubst %.c, %, $(src))

CC = gcc
CFLAGS = -Wall -g

all:$(targets)
$(targets):%:%.c
$(CC) $(CFALGS) $< -o $@
clean:
-rm $(targets)
.PHONY:clean all

//const 放在最左端，限定的是与const最接近的类型只读不可写
//const不放在最左端，const具有左结合性，限定左边的只读不可写

//const.c

#include <stdio.h>

const int n = 0;

int main(int argc, const char *argv[])
{
    /*const*/ char * /*const*/p = "hello";

    //p[0] = 'I';

    printf("%s\n", p);
    return 0;
}

//const限定词，一定要注意：限定的类型，什么是只读的，什么是可读可写的

//para_const.c

#include <stdio.h>

void str_handler(/*const*/ char *str)
{
    int i;
    for (i = 0; str[i]; i++)
    {
        str[i] -= 32;
    }
}

int main(int argc, const char *argv[])
{
    char str[] = "helloworld";

    str_handler(str);

    printf("%s\n", str);
    return 0;
}

//函数可返回的数据类型：
//                      传入变量的地址可返回
//                      静态局部变量的地址可返回
//                      动态申请的空间的首地址可返回

//function_return_type.c

#include <stdio.h>

char *mystrcpy(char *dest, const char *src)
{
    static char str[50];
    int i;

    if(dest == NULL)
        dest = str;
    for (i = 0; (dest[i] = src[i]); i++)
            ;
    return dest;
}

int main(int argc, const char *argv[])
{
    char *p = NULL;
    printf("%s\n", mystrcpy(p, "hello world"));
    return 0;
}

//双重指针的使用

//getmemory.c

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

void getmemory(char **pp)
{
    *pp = malloc(10);
}

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

    getmemory(&p);

    strcpy(p, "hello");

    printf("%s\n", p);
    return 0;
}

//1.#把函数指针当作函数的参数去用，被调的函数称为回调函数。如printstr、printnum函数

//callback.c

#include <stdio.h>

typedef void (*fun_p)(void *);

void printstr(void *str)
{
    printf("%s\n", (char *)str);
}

void printnum(void *num)
{
    printf("%d\n", (int)num);
}

void printmsg(fun_p fp, void *arg)
{
    fp(arg);
}

int main(int argc, const char *argv[])
{
    printmsg(printstr, (void *)"hello");
    printmsg(printnum, (void *)123);
    return 0;
}

//2.#函数指针的使用
//指针的赋值！！！！！！！

//function_prt.c

#include <stdio.h>

typedef int (*func_t)(int, int);

int add(int a, int b)
{
    return a + b;
}

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

    fp = add;

    printf("add: %d\n", fp(1, 2));
    return 0;
}

//3.函数指针的使用方法。在函数声明中将函数名的位置替换为函数指针，即为函数指针的定义

//function_ptr_use.c

#include <stdio.h>

int add(int a, int b)
{
    return a + b;
}

int sub(int a, int b)
{
    return a-b;
}

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

    printf("sizeof(p) = %d\n", sizeof(p));

    p = add;
    printf("add: %d\n", (*p)(1, 2));

    p = sub;
    printf("sub: %d\n", p(1, 2));

    return 0;
}

//4.注意变参函数的变参的调用顺序和压栈情况

//get_a_day.c

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

static const char *msg[]={"Sunday", "Monday", "Tueday", "Wednesday", "Thursday", "Friday", "Saterday"};

char *get_a_day(int idx)
{
    /*static char buf[20];*/

    char *buf = malloc(20);

    strcpy(buf, msg[idx]);

    printf("buf = %s\n", buf);

    return buf;
}

int main(int argc, const char *argv[])
{
    printf("%s %s\n", get_a_day(0), get_a_day(1));
    return 0;
}

//泛型函数的使用，一定要注意：泛型函数的实现函数参数类型的转换

//max_callback.c

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

typedef int (*cmp_t)(void *, void *);
typedef struct student
{
    char name[10];
    int score;
}std_t;

int cmp_int(void *a, void *b)
{
    return *(int *)a - *(int *)b;
}

int cmp_str(void *dest, void *src)
{
    return strcmp(*((char **)dest), *((char **)src));
}

int cmp_std(void *a, void *b)
{
    return ((std_t *)a)->score - ((std_t *)b)->score;
}

void *max(void *base, int len, int size, cmp_t cmp)
{
    char *baseaddr = base, *maxp = base;
    int i;

    for (i = 1; i < len; i++)
    {
        if(cmp(maxp, baseaddr + i*size) < 0)
            maxp = baseaddr + i*size;
    }

    return (void *)maxp;
}

int main(int argc, const char *argv[])
{
    int num[5], i;
    int max_int;

    srand(time(NULL));
    printf("array:");
    for (i = 0; i < 5; i++)
    {
        num[i] = rand()%100 + 1;
        printf("%4d", num[i]);
    }
    printf("\n");

    max_int = *((int *)max(num, 5, 4, cmp_int));
    printf("max_int: %d\n", max_int);


    char *str[5] = {"hello", "aka", "world", "edu", "name"};
    char **max_str;

    max_str = max(str, 5, 4, cmp_str);
    printf("max_str: %s\n", *max_str);


    std_t stud[5] = {{"name1", 54}, {"name2", 65},{"name3", 87}, {"name4", 78}, {"name5", 56}};
    std_t *s;

    s = (std_t *)max(stud, 5, sizeof(std_t), cmp_std);
    printf("max_std: %s %d\n", s->name, s->score);
    return 0;
}

//函数指针与结构体，结构体数组。
//连续使用多个scanf时，一定要注意：读入缓冲区的有效字符。
//此处的getchar不可省略，用来接收读入缓冲区中的垃圾字符

//caculator_callback.c

#include <stdio.h>

#define NUM 4

typedef int (*fun_t)(int, int);

typedef struct operation
{
    fun_t fp;
    char ch;
}oper_t;


int add(int a, int b)
{
    return a + b;
}

int sub(int a, int b)
{
    return a - b;
}

int mul(int a, int b)
{
    return a * b;
}

int mydiv(int a, int b)
{
    return a / b;
}


int main(int argc, const char *argv[])
{
    char c;
    int  a, b, i;

    oper_t oper[NUM] = {{add, '+'}, {sub, '-'}, {mul, '*'}, {mydiv, '/'}};

    while(1)
    {
        printf("operation:");
        scanf("%c", &c);

        if(c == '#')
            break;

        printf("input a b:");
        scanf("%d %d", &a, &b);

        getchar();

        for (i = 0; i < NUM; i++)
        {
            if(c == oper[i].ch)
            {
                printf("result: %d\n", oper[i].fp(a, b));
                break;
            }
        }
    }
    return 0;
}