指针小随笔

最新推荐文章于 2022-10-13 23:37:46 发布
最新推荐文章于 2022-10-13 23:37:46 发布
阅读量392 收藏
点赞数
分类专栏： c-c++ 文章标签： 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MooMLu/article/details/71056542
版权

在计算机中，内存的分配就是一块块的，内存中可以存储很多东西，不同的数据类型，指针，并且每块内存都有相应的物理地址编号。用户向计算机申请分配内存资源时，计算机将没有占用的内存资源按照某种方式分配给用户。
地址的本义也是内存存储的数据，但是这个数据是可以指向某个数据的标识。

将两个数据进行交换：

void swap(int x,int y)  
    {  
        int tmp;                //相当于只交换了形参变量的值的值 
        tmp=x;  
        x=y;  
        y=tmp; 
        printf("later形参:%d,%d\n",x,y);    
    }  
 void swap(int* x,int* y)  
    {  
        int *tmp=NULL;  
        tmp=x;  
        x=y;  
        y=tmp;     
    }

以上两种都不会真正的交换值，仅仅相当于是将实参的地址或者数据直接
拷贝了一份传给形参，对形参操作后并不会传给实参，所以并会真正起作用。实参并没有发生任何影响。

    #include <stdio.h>  
    int main()  
    {  
        int a=2,b=3;  
        void swap(int* x,int* y);  
        printf("before:%d,%d\n",a,b);  
        swap(&a,&b);  
        printf("later实参:%d,%d\n",a,b);
        printf("later实参地址:%d,%d\n",&a,&b);   
        return 0;  

    }  

    void swap(int* x,int* y)  
    {  
        int tmp;  
        tmp=*x;  
        *x=*y;  
        *y=tmp; 
        printf("later形参:%d,%d\n",*x,*y);   
        printf("later形参地址:%d,%d\n",x,y);       
    }

然而上面这部分虽然也是地址的交换，但是是将形参地址所指向的值进行交换，那么实参形参相同数据相同的情况下指向也一样，数据发生交换，地址并没有发生改变结果如下：

运行结果：
before:2,3
later形参:3,2
later形参地址:6684236,6684232
later实参:3,2
later实参地址:6684236,6684232
#include<stdio.h>
void swap(int **a,int **b)
{  
     int  *t;                 
    t=*a;   *a=*b;  *b=t;      //交换地址的地址
    printf("形参地址的地址指向的值:%d\t%d\n",a,b); 
    printf("形参地址指向的值:%d\t%d\n",*a,*b); 
}
main()
{  
 int  x=3,y=5,*p=&x,*q=&y;// p,q为x,y的地址
 printf("before实参:%d\t%d\n",x,y);//相当于交换的p,q的地址  
 printf("before实参地址:%d\t%d\n",&x,&y);
 swap(&p, &q);            //交换p,q的地址 
 printf("later实参地址指向的值:%d\t%d\n",*p,*q);
 printf("later实参地址:%d\t%d\n",p,q); 
 printf("later实参:%d\t%d\n",x,y);//相当于交换的p,q的地址 
} 
运行结果:
before实参:3    5
before实参地址:6684236  6684232
形参地址的地址指向的值:6684224  6684216
形参地址指向的值:6684232        6684236
later实参地址指向的值:5 3
later实参地址:6684232   6684236
later实参:3     5
#include<stdio.h>
void swap(int ***a,int ***b)
{  
     int  **t;                 
    t=*a;   *a=*b;  *b=t;      //交换地址的地址
    printf("形参地址的地址指向的值:%d\t%d\n",*a,*b); 
    printf("形参地址指向的值:%d\t%d\n",**a,**b); 
}
main()
{  
 int  x=3,y=5,*p=&x,*q=&y;// p,q为x,y的地址
 int **m=&p;
 int **n=&q;
 printf("before实参:%d\t%d\n",x,y);
 printf("before实参地址:%d\t%d\n",&x,&y);
 swap(&m, &n);           
 printf("later实参地址的地址指向的值:%d\t%d\n",**m,**n); 
 printf("later实参地址指向的值:%d\t%d\n",*p,*q);
 printf("later实参地址:%d\t%d\n",p,q); 
 printf("later实参:%d\t%d\n",x,y);//相当于交换的p,q的地址 
} 
运行结果:
before实参:3    5
before实参地址:6684236  6684232
形参地址的地址指向的值:6684216  6684224
形参地址指向的值:6684232        6684236
later实参地址的地址指向的值:5   3
later实参地址指向的值:3 5
later实参地址:6684236   6684232
later实参:3     5

上面的两个例子显示：当参数的高层地址对次层地址进行交换时，也会发生次层地址所指向的内容会反生交换，即在那一层发生地址指向的内容发生变化，就是那一层的问题。

int const和const int 的区别

int *const p;
p=&x;
相当于这个const定义的是这个这个指针指向的变量不会发生改变，可以将变量进行操作但是不能让这个p指针指向另外一个变量。
const int *p;
p=&x;
p=&y;
相当于const定义的是一个常量指针，这个指针不能被发生改变，不能对这个指针直接赋值如：
*p=81;//这种情况不会发生.
间接改变*p的值只能通过p指针指向不同的变量来执行：
如：

#include <stdio.h>
int main()
{
    int x=9,y=90;
    int *const p=&x;
    const int *q;
    //p=&x;
    //p=&y;
    q=&x;
    q=&y;
    printf("*p->:%d\n",*p);
    printf("*q->:%d\n",*q);
    x=90;
    y=100;
    printf("*p->:%d\n",*p);
    printf("*q->:%d",*q);
}
*p->:9
*q->:90
*p->:90
*q->:100

int const* p=&x;int const*第一遍初始化时就必须直接将指向内容定义到。否则报错。

指针级应用理解

（下面代码来源于网上大牛：）

#include <stdio.h>
#include <malloc.h>
struct NODE {
    char         data;
    struct NODE *U;//上
    struct NODE *R;//右
    struct NODE *D;//下
    struct NODE *L;//左
} *B,*q;
struct NODE *m[10];
char p[3][4];
int i;
void show_node(struct NODE *s,int y,int x) {
    if (NULL==s) return;
    for (i=0;i<10;i++) {
        if (m[i]==s) return;
    }
    for (i=0;i<10;i++) {
        if (NULL==m[i]) {
            m[i]=s;
            break;
        }
    }
    p[y][x]=s->data;
    show_node(s->U,y-1,x  );
    show_node(s->R,y  ,x+1);
    show_node(s->D,y+1,x  );
    show_node(s->L,y  ,x-1);
}
void show_xlinks(struct NODE *b) {//显示整个十字链表
    int y,x;

    for (i=0;i<10;i++) m[i]=NULL;
    for (y=0;y<3;y++) {
        for (x=0;x<4;x++) {
            p[y][x]=' ';
        }
    }
    show_node(b,1,1);
    for (y=0;y<3;y++) {
        for (x=0;x<4;x++) {
            printf("%c",p[y][x]);
        }
        printf("\n");
    }
    printf("----\n");
}
void swap_xlinks(struct NODE **pa,struct NODE **pb) {
    struct NODE *a,*aU,*aR,*aD,*aL;
    struct NODE *b,*bU,*bR,*bD,*bL;
    struct NODE *t;

    if (pa==pb) return;

    a=*pa;
    aU=a->U;
    aR=a->R;
    aD=a->D;
    aL=a->L;

    b=*pb;
    bU=b->U;
    bR=b->R;
    bD=b->D;
    bL=b->L;

    if (aU && aU!=b) aU->D=b;
    if (aR && aR!=b) aR->L=b;
    if (aD && aD!=b) aD->U=b;
    if (aL && aL!=b) aL->R=b;

    if (bU && bU!=a) bU->D=a;
    if (bR && bR!=a) bR->L=a;
    if (bD && bD!=a) bD->U=a;
    if (bL && bL!=a) bL->R=a;

    t=a->U;a->U=b->U;b->U=t;if (a->U==a) a->U=b;if (b->U==b) b->U=a;
    t=a->R;a->R=b->R;b->R=t;if (a->R==a) a->R=b;if (b->R==b) b->R=a;
    t=a->D;a->D=b->D;b->D=t;if (a->D==a) a->D=b;if (b->D==b) b->D=a;
    t=a->L;a->L=b->L;b->L=t;if (a->L==a) a->L=b;if (b->L==b) b->L=a;

    if (a==*pa) *pa=b;
    if (b==*pb) *pb=a;
}
void free_xlinks() {
    for (i=0;i<10;i++) if (NULL!=m[i]) free(m[i]);
}
int main() {
    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='1';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q记录为起始节点B//
    B=q;                //   1
                        //
    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='2';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的上边    //   2
    B->U=q;             //   1
    q->D=B;             //

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='3';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的右边    //   2
    B->R=q;             //   13
    q->L=B;             //

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='4';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的下边    //   2
    B->D=q;             //   13
    q->U=B;             //   4

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='5';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的左边    //   2
    B->L=q;             //  513
    q->R=B;             //   4

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='6';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的左上    //  62
    B->L->U=q;          //  513
    B->U->L=q;          //   4
    q->R=B->U;
    q->D=B->L;

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='7';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的右上    //  627
    B->R->U=q;          //  513
    B->U->R=q;          //   4
    q->L=B->U;
    q->D=B->R;

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='8';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的右下    //  627
    B->R->D=q;          //  513
    B->D->R=q;          //   48
    q->L=B->D;
    q->U=B->R;

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='9';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在B的左下    //  627
    B->L->D=q;          //  513
    B->D->L=q;          //  948
    q->R=B->D;
    q->U=B->L;

    //创建1个节点的十字链表q
    q=(struct NODE *)malloc(sizeof(struct NODE));
    if (NULL==q) return 1;
    q->data='a';
    q->U=NULL;
    q->R=NULL;
    q->D=NULL;
    q->L=NULL;

    //将q放在3的右边    //  627
    B->R->R=q;          //  513a
    q->L=B->R;          //  948

    printf("begin:\n");
    show_xlinks(B);

    printf("swap 1a:\n");
    swap_xlinks(&B,&B->R->R);
    show_xlinks(B);

    printf("swap a3:\n");
    swap_xlinks(&B,&B->R);
    show_xlinks(B);

    printf("swap 34:\n");
    swap_xlinks(&B,&B->D);
    show_xlinks(B);

    printf("swap 45:\n");
    swap_xlinks(&B,&B->L);
    show_xlinks(B);

    printf("swap 52:\n");
    swap_xlinks(&B,&B->U);
    show_xlinks(B);

    printf("swap 28:\n");
    swap_xlinks(&B,&B->R->D);
    show_xlinks(B);

    printf("swap 47:\n");
    swap_xlinks(&B->L,&B->R->U);
    show_xlinks(B);

    free_xlinks();

    printf("end.\n");
    return 0;
}
运行结果：
begin:
627
513a
948
----
swap 1a:
627
5a31
948
----
swap a3:
627
53a1
948
----
swap 34:
627
54a1
938
----
swap 45:
627
45a1
938
----
swap 52:
657
42a1
938
----
swap 28:
657
48a1
932
----
swap 47:
654
78a1
932
----
end.

====================================================

MooMLu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组与指针运算
04-21
数组与指针运算 指针深度讲解教程
Go学习随笔（五）指针\指针的指针\指针数组\指针传递函数
01-07
大家都知道所有的指针变量都是一个内存位置，每个内存位置都有其定义的地址，可以使用&运算符来访问它，这个运算符表示内存中的地址。 func main() { a := 10 fmt.Printf(%x\n, &a) //打印变量a的地址 返回：c...
指针随笔
qq_51162591的博客
11-21 61
#include<iostream> using namespace std; int* & f(int **p); int main() { int a[]={1,2,3}; int** p; cout<<"&p"<<&p<<endl; cout<<"p"<<p<<endl;//p是一个二级指针 //cout<<"*p"<<*p&l..
C语言指针随笔
zqs656546的博客
07-07 154
声明变量： int a = 112, b = -1; float c = 3.14; int *d = &a; float *e = &c; 变量d和e声明为指针变量，并用其他变量的地址予以初始化。d和e的内容是地址而不是整型或浮点型数值。从图中可以看出d的内容与a的存储地址一致，而e的内容与c的存储地址一致，这是我们对这两个指针进行初始化时所期望的结果。 注意：不能简单的认为由于d和e是指针，所以它们能自动获得存储于位置100和108的值（即112和3.14），因为变量的值就是.
随笔-指针相关
mengyetxz的博客
09-26 260
指向函数的指针：int (*p)(int, float); 数据类型 （指针变量名）（形参列表）。 如何理解C语言中的 typedef:如何理解C语言中的 typedef? 理解typedef -C++中如何定义指向函数指针的指针？ 定义的样子，和使用的时候的样子是一样的。 《C陷阱与缺陷》– 第一章 指针： The & is the “address of” operator - i
指针学习随笔
12november的博客
10-13 109
指针随笔
指针随笔解疑
m0_61821890的博客
09-09 173
内存单元的编号从零开始的非负整数范围：32位->4G【0~4G-1】64位->8G【0~8G-1】提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
c指针语法随笔
lnwechag的博客
09-29 99
char test1[] = "test"; char *test2; // 空指针，存放地址0x20011604，指向地址0 uint32_t test1_addr; uint32_t *test2_addr; test1_addr = (uint32_t)test1; test1_addr = (uint32_t)&test1; test1_addr = (uint32_t)&test1[0]; 都是取test1的首地址 test2_addr = (uint32_t*)&te
C语言_指针随笔
风哲的博客
03-02 264
指针： 指针就是地址，地址就是指针。地址就是内存单元的编号。指针变量是存放地址的变量（例：int* p，这里的p就是指针变量，用于存放地址）     指针和指针变量是两个不同的概念：平时也把指针变量间读为指针，也就是说下面示例代码中的p既是我们所说的指针，也是我们所说的指针变量。     例： 指针里面存放的是100：这句话中，指针就是地址指针里面存放的是地址：这句话中，指
c语言指针系统学习,C语言与指针学习随笔
weixin_39559804的博客
05-19 75
C语言与指针学习随笔，勉励自己学习用！-->变量不一定按照声明顺序保存在内存中-->&运算符可取得变量的地址(指向变量的指针)*运算符可取得地址的变量int j=10;int *p=&j; //指针p指向jint k=*p; //取得指针p指向的变量-->声明int *p;int* p; 　　 //等价int* p,p1; //无法声明两个指针变量,第二变...
智能指针随笔
weixin_53022668的博客
10-31 54
auto_ptr 托管资源，auto_ptr析构时会自动释放所保管的资源而免去忘记或因各种原因忘记delete的情况。 auto_ptr被销毁时会自动删除它的指向之物 只有一个auto_ptr对象指向一个资源，当auto_ptr被复制时，资源的拥有权会被被复制物转到目标物。被复制的指针会变成nullptr，复制所得指针将取得资源的唯一拥有权。 share_ptr share_ptr 包含引用计数，share_ptr复制时会增加引用计数，而在引用计数为0时才会删除原始资源。 tr1::share_
C++智能指针实现（包含拷贝构造，赋值函数，引用解引用重载）
03-22
在C++编程中，智能指针是一种非常重要的概念，它能自动管理动态内存，避免内存泄漏。本主题将深入探讨如何实现一个简单的智能指针，包括拷贝构造函数、赋值运算符以及引用和解引用操作符的重载。我们将使用C++标准库...
golang随笔杂谈
09-19
根据提供的文档内容，我们可以从中提炼出关于Golang的一些知识点，主要集中在指针类型的理解与使用上。下面将详细展开这些知识点： ### golang指针类型详解 #### 1. 指针的基本定义与初始化 - **定义形式**：`var ...
ACE学习随笔
01-15
这个宏定义了是否启用位置无关指针（Position Independent Pointers）。位置无关代码（Position Independent Code, PIC）常用于动态链接库，使得代码可以在内存中的任何位置正确执行。如果`ACE_HAS_POSITION_...
基于springboot+mybatis实现的学生管理系统
08-14
springboot 但功能包含(学生，教师，管理员),项目基于springboot2.1.x实现的管理系统。如果你是spring boot初学者，那么此项目非常适合你。如果喜欢，请随手给个star，谢谢。 编译环境 ： jdk 1.8 mysql 5.5 tomcat 7 框架 ： springboot2.0 mybatis jar包管理工具： Maven 编译器 ： IDEA 系统功能 : 学生信息管理 班级信息管理 教师信息管理 课程信息管理 选课信息管理 考勤信息管理 请假信息管理 成绩信息管理 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
rabbitmq-server-3.8.30-1.el7.noarch.rpm
08-14
rabbitmq-server-3.8.30-1.el7.noarch.rpm 是 RabbitMQ 3.8.30 版本的 RPM 软件包，专为 CentOS 7、RHEL 7 等使用 el7 标识的 Linux 发行版构建的。noarch 表示该包是架构无关的，即适用于任何 CPU 架构。此软件包包含 RabbitMQ 服务器及其所需的运行时组件。 rabbitmq-server-3.8.30-1.el7.noarch.rpm 是 RabbitMQ 3.8.30 版本的 RPM 软件包，专为 CentOS 7、RHEL 7 等使用 el7 标识的 Linux 发行版构建的。noarch 表示该包是架构无关的，即适用于任何 CPU 架构。此软件包包含 RabbitMQ 服务器及其所需的运行时组件。
BMS电池管理常用芯片-ads1256(耘天科技).pdf
最新发布
08-14
BMS电池管理常用芯片，让设计与众不同。
基于Android网络音乐播放器APP设计与实现.docx
08-14
基于Android网络音乐播放器APP设计与实现.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值