指针的学习

来源：互联网发布：栅格数据矢量化编辑：程序博客网时间：2024/06/04 19:10

《c和指针》一书的笔记：

1.指针.间接访问和变量

*&a = 25;

这个表达式结果是a = 25, &a得到的是a的地址，然后*对操作数进行访问就是a（有趣的表达式）

看另外一个，关于指针常量的

如果100这个地址存放一个a这个变量

*100 = 20

这样的赋值是非法的，下面这种就OK

*(int *)100 = 20; 100从"整型"转化为"指向整型的指针"

2.指针的指针

int a = 20;

int *b = &a;

int **c = &b;

可以这样理解：c指向的b的地址,b为一个指针，*c 为b的内容=&a为a的地址，所以**c对a进行操作

3.指针表达式的一些用法（有意思的表达式）

char ch = 'a';

char *cp = &ch;

1.表达式 *cp + 1;

做为右值取得*cp的一份拷贝a,然后加1 得到的值为b

表达式的存储位置并未清晰定义,所以不能做左值

2.*(cp+1)

左值,cp指向下一个位置的地址

右值,cp指向下一个位置的值

3.++cp 和 cp++

4.*++cp

先++cp,然后再*;

左值就是cp的下一个位置的地址

右值就是cp的下一个地址的内容值

5.*cp++

1.++操作符产生一个拷贝,2.然后++操作符增加cp的值,3.在cp的拷贝上执行间接访问

6.++*cp

至右向左结合

*cp间接访问,然后这个值加1

       7.(*cp)++

       8.++*++cp
             (*++cp)得到下一个地址的内容然后再加1

9.++*cp++

*cp得到地址的内容也就是*cp的值然后加1 cp++指向下一个地址

4.关系运算符
    #define N_VALUES    5
    float values[N_VALUES];
    float *vp;

    for(vp = &values[0];vp < &values[N_VALUES];)
        *vp++ =0;

    当vp指向values[4]为的位置时，vp++,指到数组的下一个位置，循环停止

    for(vp = &values[N_VALUES];vp>&values[0];)
        *--vp = 0;

    当vp指向values[1]的位置时,--vp,指到values[0],*vp = 0;vp=&values[0];循环终止

    for(vp = &values[N_VALUES-1];vp >= &values[0];vp--)        // 在unix_center上测试是没有问题的
        *vp = 0;
    vp 指向values[0]下一个元素这个是非法的。


5.有意思的两个题
    (1)单个字符匹配
        char *find_char(char const *source,char const *chars)
        {    char curChar;
            char *curSorChar;
            while((curChar = *chars++ )!= '/0')
            {
                    curSorChar = source;
                    while((*curSorChar) !='/0')
                    {
                            if(curChar == *curSorChar)
                            {
                                    return curSorChar;
                            }
                            else
                            {
                                    curSorChar++;
                            }
                    }
            }
            return NULL;
        }

    (2)字符串匹配
        #define NUL '/0'
        #define FALSE 0;
        #define TRUE 1;
        char *match(char *str, char *want)
        {
                while(*want != NUL)
                    if(*str++ != *want++)
                        return NULL;
                return str;
        }

        int find_str(char *str,char const *substr)
        {
            char *next;

            while(*str != NUL){
                next = match(str,substr);
                if(next != NULL)
                    break;
                str++;
            }

            if(*str == NUL)
                return FALSE;
            else
                return TRUE;
        }

(3)关于字符窜的反序问题，用指针来操作，指向同一数组的指针进行算术运算
    void reverse_string(char *str)
    {
        char *start,*end;
        char temp;
        start = str;
        end = str;
        while(*end != '/0')
        {
                end++;
        }
        end--;
        while(start<end)
        {
                temp = *start;
                *start++ = *end;
                *end-- = temp;
        }
    }

    str 一份拷贝
    void revers_string(char *str)
    {
        char *last_char;

        for(last_char = str;*last_char != '/0'; last_char++)
                ;

        last_char--;

        while(str < last_char)
        {
                char temp;
                temp = *str;
                *str++ = *last_char;
                *last_char-- = temp;
        }
    }