zoukankan      html  css  js  c++  java
  • 指针

    1.sizeof运算符

    #include <stdio.h>
    int main()
    {
        int a = 10;
        char b = 'a';
        //sizeof运算符计算数据类型在内存中占的字节大小,返回值类型为unsigned int ->size_t
        //格式 : sizeof(数据类型) sizeof(变量名)
        int len = sizeof(a);
        int lens = sizeof(b);
        printf("整型变量在内存中占的字节大小:%d
    ",len);
        printf("字符型变量在内存中占的字节大小:%d
    ",lens);
        /*
            char ->1
            short ->2
            int ->4
            long ->4
            float ->4
            double ->8
        */
        return 0;
    }


    2.变量内存地址的打印

    #include <stdio.h>
    int main(void)
    {
        int a =10;
        int b =20;
        //占位符 %p 打印数据的内存地址 unsigned int 十六进制表示
        printf("变量a的内存地址:%p
    ",&a);
        printf("变量b的内存地址:%p
    ",&b);
        return 0;
    }


    3.指针地址

    #include <stdio.h>
    int main()
    {
        int a = 10;
        //获取变量a的内存地址
        //指针类型定义
        //int* p =&a;
        //指针变量
        int* p;
        //指针变量p和变量a建立关系
        p = &a;
        //打印内存地址
        printf("%p
    ",&a);
        printf("%p
    ",p);
        //打印变量的值
        printf("%d
    ",a);
        //*p 对指针变量p进行取值操作
        //& 升维度 *降维度
        printf("%d
    ",*p);
        return 0;
    }


      4.通过指针改变数据值

    #include <stdio.h>
    int main()
    {
        int a = 10;
        //int* 是一种数据类型
        int* p = &a;
        //* 运算符
        *p = 100;
        printf("%d
    ",a);
        return 0;
    }

    #include <stdio.h>
    int main()
    {
        //指针在内存中占的字节大小
        int a = 10;
        int* p = &a;
        int len = sizeof(p);
        //所有指针类型在32位操作系统下是4字节,在64位操作系统中占8字节
        printf("整型指针在内存中占的字节:%d
    ",len);
        printf("字符型指针在内存中占的字节:%d
    ",sizeof(char*));
        printf("短整型指针在内存中占的字节:%d
    ",sizeof(short*));
        printf("长整型指针在内存中占的字节:%d
    ",sizeof(long*));
        printf("单精度型指针在内存中占的字节:%d
    ",sizeof(float*));
        printf("双精度型指针在内存中占的字节:%d
    ",sizeof(double*));
        return 0;
    }


    5.指针作为函数参数

    #include <stdio.h>
    void swap(int* a,int* b)
    {
        int temp = *a;
        *a = *b;
        *b = temp;
    }
    int main()
    {
        int a = 10;
        int b = 20;
        //值传递 形参不能改变实参的值
        //地址传递,形参可以改变实参的值
        swap(&a,&b);
        printf("%d
    ",a);
        printf("%d
    ",b);
        return 0;
    }


    6.数组作为函数参数

    #include <stdio.h>
    //int arr[] 数组名作为函数参数会退化为指针
    //数组名本身就是一个地址 指向数组的首地址
    void BubbleSort(int* arr,int len)
    {
        int i,j;
        int temp;
        for(i=0;i<len-1;i++)
        {
            for(j=0;j<len-i-1;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    temp = arr[j];
                    arr[j] = arr [j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return;
    }
    int main()
    {
        int i;
        int arr[]={8,1,5,9,2,10,6,3,7,4};
        BubbleSort(arr,10);
        for(i=0;i<10;i++)
        {
            printf("%d
    ",arr[i]);
        }
        return 0;
    }


    7.函数返回值为指针类型

    #include <stdio.h>
    int a = 10;
    int* test()
    {
        return &a;
    }
    int main()
    {
        int* p = test();
        printf("%p
    ",p);
        printf("%p
    ",&a);
    
        printf("%d
    ",*p);
        printf("%d
    ",a);
        return 0;
    }


    8.指针和数组

    8.1

    #include <stdio.h>
    int main()
    {
        int arr []  ={1,2,3,4,5,6,7,8,9,10};
        //数组名是数组的首地址  是一个常量
        printf("%p
    ",&arr[0]);
        printf("%p
    ",arr);
        return 0;
    }

    8.2

    #include <stdio.h>
    int main()
    {
        int arr []  ={1,2,3,4,5,6,7,8,9,10};
        //在将数组赋值给指针变量时,不需要取地址操作 本身就是地址
        int * p;
        p = arr;
        printf("%d
    ",arr[0]);
        //通过指针间接操作数组
        printf("%d
    ",p[0]);
        //int* 指针+1 内存地址相当于 +sizeof(int);
        printf("%d
    ",*(p+1));
        return 0;
    }

    8.3指针当做数组操作

    #include <stdio.h>
    int main()
    {
        int i;
        int arr []  ={1,2,3,4,5,6,7,8,9,10};
        //在将数组赋值给指针变量时,不需要取地址操作 本身就是地址
        int * p;
        p = arr;
        for(i=0;i<10;i++)
        {
            printf("%d ",*(p+i));
            if(*(p+i) ==10)
            {
                printf("
    ");
            }
        }
        for(i=0;i<10;i++)
        {
            //指针加上偏移量
            printf("%d ",*(p+i));
        }
        return 0;
    }

    8.4 指针减法

    #include <stdio.h>
    int main(void)
    {
        int step;
        char ch [] ="hello world";
    
        //指向o字符元素
        char* p = &ch[4];
        //ch数组名默认指向第一个数组下标
        step = p -ch;
        printf("%d
    ",step);
        return 0;
    }


     9.指针数组

    #include <stdint.h>
    int main()
    {
        int i;
        int a = 10;
        int b = 20;
        int c = 30;
        //指针数组  指针类型的数组
        int* arr[3] ={ &a,&b,&c};
        //指针数组存储指针变量
        *arr[2] = 123;
        for(i=0;i<3;i++)
        {
            printf("%d
    ",*arr[i]);
        }
        return 0;
    }


    10.多级指针

    #include <stdio.h>
    int main()
    {    int a = 10;
        int b = 20;
        //使用一级指针接收变量地址
        int* p =&a;
        int* q =&b;
        //使用二级指针接收一级指针的地址
        int** p1 = &p;
        printf("%d
    ",**p1);//-->10
    
        *p1 = q;//间接改变一级指针的值
        printf("%d
    ",**p1);//-->20
        **p1 = 123;//二级指针间接改变变量的值
        printf("%d
    ",**p1);//-->123
        return 0;
    }

  • 相关阅读:
    为什么接口类型可以直接new?
    Eclipse查看JDK源码
    模板模式与策略模式/template模式与strategy模式/行为型模式
    [LeetCode] 105. Construct Binary Tree from Preorder and Inorder Traversal(根据二叉树的前序和中序遍历构建二叉树)
    [LeetCode] 114. Flattern Binary Tree to Linked List(将二叉树扁平化成单链表)
    [LeetCode] 208. Implement Trie (Prefix Tree)(实现字典树)
    [LeetCode] 337. House Robber Ⅲ(偷家贼之三)
    [LeetCode] 621. Task Scheduler(任务调度器)
    [LeetCode] 394. Decode String(解码字符串)
    [LeetCode] 11. Container with Most Water(盛水量最多的容器)
  • 原文地址:https://www.cnblogs.com/zjm1999/p/10383041.html
Copyright © 2011-2022 走看看