Standard C Episode 11

复杂声明。

  C语言常常因为声明的语法问题而受到人们的批评，特别是设计到函数指针的语法。C语言的语法力图使声明和使用相一致。对于简单的情况，C语言的这种做法很有效，但是，如果情况比较复杂，则容易让人混淆，原因在于，C语言的声明不能从左至右阅读，而且复杂的声明往往还使用了太多的圆括号。这里看两个声明：

int *f();    /* f: 是一个函数， 它返回一个指向int类型的指针 */

int (*pf)();   /* pf: pf是一个指向函数的指针，该函数返回一个int类型的对象 */

从上面两个例子含义差别说明：*是一个典型的前缀运算符（操作符），其优先级低于小括号()，所以，第二种含义的正确表达离不开小括号，可见，声明中使用小括号可以保证正确的结合顺序。

 

往往可以如下这样将C语言声明转换为文字描述，比如：

char **argv      

      argv: argv is a pointer to pointer to char

int (*daytab)[13]

    daytab: daytab is a pointer to an array of 13 int

int *daytab[13]

    daytab: daytab is an array of 13 pointers to int

void *comp()

    comp: comp is a function with 0 arguments and returning a pointer to void

void (*comp)()

    comp: comp is a pointer to a function with 0 arguments and returning a void

char (*(*x())[])()

    x: x is a function with 0 arguments and returning a pointer to an array of pointer to a function with 0 arguments and returning char

char (*(*x[3])())[5]

    x: x is an array of 3 pointer to a function with 0 arguments and returning pointer to an array of 5 char

 

 

/*
 * 指针常量与常量指针
 * */

#include <stdio.h>

main()
{
    int value = 3;
    const int *p_value = &value;//p_value是常量指针，简称"常指针"。 p_value is pointer to const int.
    //*p_value = 4;//编译器报错error: assignment of read-only location '*p_value'
    {
    int * const p_value = &value;//p_value是指针常量。 const p_value is a pointer to int
    (*p_value)++;//特别注意：语句中括号去掉编译器将报错！因为*p_value++被编译器理解为 先使用p_value中记录的数据间接访问，然后给p_value加一。
    //p_value = NULL;//编译器报错error: assignment of read-only location 'p_value'
    }
    p_value = NULL;

}

 

 

/*
 * 二级指针练习
 *
 * 切割字符串abcd,efg,hijkl,likk,l为abcd
 * */

#include <stdio.h>
#include <stdlib.h>
void split(char *p_str, char **pp_str) {
    int pos = 0;
    for (pos = 0; p_str[pos] != '\0'; pos++)
        if (p_str[pos] == ',')
            break;
    pos--;
    char *p_result = NULL;
    p_result = (char *)calloc(pos, sizeof(char));
    if (p_result) {
        for (*(p_result + pos) = '\0'; pos >= 0; pos--) {
            *(p_result + pos) = *(p_str + pos);
        }
    }

    *pp_str = p_result;
}


int main()
{
    char *p_str = NULL;
    split("abc,defg,kjk", &p_str);
    printf("%s\n", p_str);
    free(p_str);
    p_str = NULL;

    return 0;
}

 

 

/*
 * 函数指针：指向函数的指针练习
 *
 * 函数名称代表函数本身整个存储区，函数名称还代表着函数中的第一条语句的地址。函数名取址是函数地址，是整个函数的地址。这和数组名称一样，数组名称代表数组本身的整个存储区，数组名称还代表数组第一个元素的地址。数组名取址是整个数组的地址。
 *
 * 函数地址。 从地址信息上看函数地址就是函数中第一条语句所在的地址。
 *
 * */

#include <stdio.h>

int main()
{
    int add(int , int);
    int sub(int , int);
    printf("add是%p\n", add);
    printf("&add是%p\n", &add);

    int (*p_f)(int, int);
    p_f = add;
    printf("p_f(1, 1)是%d\n", p_f(1, 1));

    int (*p_func)(int, int) = NULL;
    p_func = add;
    printf("p_func(1, 1)是%d\n", p_func(1, 1));
    p_func = sub;
    printf("p_func(1, 1)是%d\n", p_func(1, 1));

    typedef int (*p_function)(int, int);
    p_function p_f1 = NULL;
    p_f1 = sub;
    printf("p_f1(1, 1)是%d\n", p_f1(1, 1));
    

    return 0;
}

int add( int value, int value1)
{
    return value + value1;
}
int sub( int value, int value1)
{
    return value - value1;
}

 

 

/*
 * 函数指针练习
 *
 *
 * */
#include <stdio.h>

int add(int, int);
int sub(int, int);

int main()
{

    int (*p_func)(int, int) = NULL;

    int opr = 0;
    printf("输入+将完成1+1计算，输入-将完成1-1运算:");
    scanf("%c", &opr);
    switch (opr) {
        case '+':
            p_func = add;
            break;
        case '-':
            p_func = sub;
            break;
        default:
            printf("程序错误\n");
            return -1;
    }

    printf("运算 %c 结果是%d\n", opr, p_func(1, 1));

    return 0;
}


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

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