精华内容
下载资源
问答
  • 2022-05-06 17:07:50

    今天遇到的问题是:
    指针p1和指针p2指向同一块地址。
    先释放了p1,后释放p2,出错。
    错误原因:
    释放指针指的是释放这块空间。
    这块空间已经释放之后就可以被其他的使用。
    而再次释放此指针会出错。

    更多相关内容
  • 指向同一地址指针 pointer *p1; pointer *p2; p2=p1; ⭐ p2=p1是让p2和指向同一内存空间,但如果后续p1地址变了,p2的地址不会随之改变。是浅拷贝 总结:不要让两个指向同一地址指针同时操作这个内存空间,会...

    一 指向同一地址的指针

    pointer *p1;
    pointer *p2;
    p2=p1;
    ⭐ p2=p1是让p2和指向同一内存空间,但如果后续p1地址变了,p2的地址不会随之改变。是浅拷贝
    总结:不要让两个指向同一地址的指针同时操作这个内存空间,会出错

    1
    	BstNode* p1=tree->GetRoot();//p1=null
    	BstNode* p2 = p1;//p2和p1指向同一地址空间 null
    	cout << p1->data;//地址为0153F308
    	p1= new BstNode(1);//为p1分配空间
    	cout << p1->data;//地址为01540DE8
    	cout << p2->data<<endl;//error 地址为0153F308  p2=null2
    	BstNode* p1=tree->GetRoot();//p1=null
    	BstNode* p2 = p1;//p2和p1指向同一地址空间 null
    	p1= new BstNode(1);//为p1分配空间
    	p2 = p1;//p1和p2指向同一地址空间 BstNode(1)
    	delete p1;
    	cout << p2->data<<endl;// p2->data=????  但p2能访问
    	cout << p1->data;//error p1为空指针
    

    二 指针的引用

    pointer *p1;
    pointer *p2;
    p2=&p1;
    p2和p1实际上相同,p2是p1的别名。是深拷贝

    1
    	BstNode* p1=tree->GetRoot();//p1=null
    	BstNode* &p2 = p1;//p2和p1指向同一地址空间 null
    	p1= new BstNode(1);//为p1分配空间
    	cout << p1->data;//地址为00F70C700
    	cout << p2->data<<endl;//地址为00F70C70022
    	BstNode* p1=tree->GetRoot();//p1=null
    	BstNode* p2 = p1;//p2和p1指向同一地址空间 null
    	p1= new BstNode(1);//为p1分配空间
    	p2 = p1;//p1和p2指向同一地址空间 BstNode(1)
    	delete p1;
    	cout << p2->data<<endl;// error p2为空指针
    	cout << p1->data;//error p1为空指针
    	
    

    三、应用

    void BST_Insert(BstNode* &Node,BstNode* parent, int data)
    ①对传进来的参数Node进行分类

    • Node为nullptr 这时应该使用&符号,因为nullptr并不指向一确定空间,当修改函数内部的类时,外部的并不会修改。解决方法:return Node用于接受
    • Node不为nullptr 随便都行
    展开全文
  • 5、6、7、8是字面值常量,存放在代码区,是不能修改的,“abc”本身就是一个地址,然后你在栈区定义了四个指针都是指向同一个地址指针比较的时候比较的是指针存放的地址,而不是指针本身的地址,当然5、6、...
    代码如下:

    #include <iostream>
    using  namespace  std;
     
    int  _tmain( int  argc, _TCHAR* argv[])
    {
     
         char  str1[] =  "abc" ;
         char  str2[] =  "abc" ;
         const  char  str3[] =  "abc" ;
         const  char  str4[] =  "abc" ;
     
         const  char  * str5 =  "abc" ;
         const  char  * str6 =  "abc" ;
     
         char  * str7 =  "abc" ;
         char  * str8 =  "abc" ;
     
         cout<<boolalpha<<(str1 == str2) <<endl;  //false
         cout<<boolalpha<<(str3 == str4) <<endl; //false
         cout<<boolalpha<<(str5 == str6) <<endl; //true
         cout<<boolalpha<<(str7 == str8) <<endl; //true
     
        
         return  0;
    }

    原因:

    5、6、7、8是字面值常量,存放在代码区,是不能修改的,“abc”本身就是一个地址,然后你在栈区定义了四个指针都是指向同一个地址,
    指针比较的时候比较的是指针存放的地址,而不是指针本身的地址,当然5、6、7、8都是一样的值。
    同时字符数组呢,是存在栈区,四个数组变量,每个变量比较的都是数组的首地址,四个不同的变量当然地址不一样啊。


    展开全文
  • 看数据结构看到循环链表的合并,很奇怪为什么最后要free掉p,这样rearB->next不就会随机指向其他的内存了吗![图片说明](https://img-ask.csdn.net/upload/201708/16/1502850283_66326.png)
  • 多重继承下,不同基类指针指向同一子类对象的地址问题——腾讯一笔试题  2 原文:http://www.haogongju.net/art/1694028 多继承时,父类指针指向子类对象时,父类指向的不是子类开始地址,而是子类...

    原文:http://www.haogongju.net/art/1694028

    多继承时,父类指针指向子类对象时,父类指向的不是子类开始地址,而是子类中对应父类的结构的类对象的基地址,所以,当多个父类指向同一个子类时,父类的指针值其实是不一样的。


    5.观察下面一段代码: 
    class ClassA 

    public: 
    virtual ~ ClassA(){}; 
    virtual void FunctionA(){}; 
    }; 


    class ClassB 

    public: 
       virtual void FunctionB(){}; 
    }; 


    class ClassC : public ClassA,public ClassB 

    public: 
    }; 
      
    ClassC aObject; 
    ClassA* pA=&aObject; 
    ClassB* pB=&aObject; 
    ClassC* pC=&aObject; 


    关于pA,pB,pC的取值,下面的描述中正确的是: 
    A.pA,pB,pC的取值相同.               B.pC=pA+pB 
    C.pA和pB不相同                      D.pC不等于pA也不等于pB


    这个是多重继承的问题。在《Thinking in C++》第二卷的363页看到重复子对象这部分的内容,明白了怎么回事。

    以上两个基类均含有虚函数,故其大小至少有一个虚函数表的指针大小,结构大概是这样的:


    ClassA类数据成员
    ClassB类数据成员
    ClassC类其他数据成员

    可以看出对象aObject以ClassA子对象开头,然后是ClassB子对象部分,最后的部分来自ClassC类本身。ClassC的对象既是一个ClassA也是一个ClassB。

    故aObject可以向上类型转换到两者中任何一个基类型。


    当向上类型转换为ClassA时,结果指针指向ClassA子对象部分,刚好在ClassC对象的开始位置,所以地址pA和pC是相同的。

    当向上类型转换到ClassB时,结果指针必须指向ClassB子对象所在的实际位置,因为类ClassB并不知道有关ClassC的事情。

    所以上题的答案应为C。


    但是这个地方有个好玩的现象:

    如果添加如下代码:cout<<"pC==pB?"<<boolalpha<<(pC==pB)<<endl;

    则返回值永远都是true,尽管他们的地址输出的时候并不相同。因为pC在pC==pB的过程中被隐式转换为ClassB*,以使得比较有意义。




    基类子类在内存中的存储

    class a 
    {

    public: 
    int aa

    }; 


    class b:public a 
    {

    public: 
    int bb; 

    从内存的来看 
    如a 
    ---------| 
    |占一个int数据大小--| 
    |----(aa数据)------| 
    |--------- 
    而b则是 
    ---------|--------- 
    |占一个int数据大小--|占一个Int数据大小--| 
    |从a中继承而来------|---(bb数据----------| 
    |------------------ 
    当定义一个基类类型的指针时 
    a *p;这时,这个指针指向的是a类型的数据 
    当p指针指向派生类的时候,因为p是a类型的指针,所以*p只解释为a类型数据的长度,即 
    ————————-|--------- 
    |占一个int数据大小--|占一个Int数据大小--| 
    |从a中继承而来------|-----(bb数据)-------| 
    |------------------ 
    |------------|------------| 
    |-p只指向这个区域_--| 

    因此,当基类的指针(P)指向派生类的时候,只能操作派生类中从基类中继承过来的数据。 
    指向派生类的指针,因为内存空间比基类长,会导致严重了后果,所以不允许派生类的指针指向基类。而基类的指针可以指向派生类。 

    C++的多态性能解决基类指针不能操作派生类的数据成员的问题。

     

    用C++比较好说明白:       
      1:指针的可访问性是由指针的定义决定的,比如说用BaseClass定义的指针,可访问的范围就是BaseClass的内存区域       
      2:允许用一个指向基类的指针指向派生类,由于被指向的对象的内存空间大于指针的可访问空间,所以这种向上映射是安全的       
      3:对象在调用虚函数的时候,是调用父类的函数还是调用派生类的函数,是和对象的类型有关的,比如说一个派生类B,其父类是A,则B的对象调用父类中被声明为VIRTUAL的函数时,被B   所OVERRIDE的函数调用的是B里的函数,而B没有OVERRIDE的函数调用的是基类里的函数 

    展开全文
  • 1,智能指针 2,在使用时,进行地址判断是否指向同一地址
  • 指向同一数组的两个指针变量 相减 表示 相差元素个数,可以 比较 地址编号大小,两个指针变量不能相加 指针变量加一个数表示 跳过(指针变量类型的字节数)*(这个数)的字节数 数组名[ 不越界的情况下可以为复负数 ],...
  • 怎么避免两个指向同一个地址的多次释放问题本帖最后由 wallwind 于 2014-03-05 20:44:48 编辑比如以下代码#include#includeintmain(){int*ptr=malloc(10*sizeof(int));int*ptr2=ptr;if(ptr){free(ptr);ptr=NULL;...
  • int *p,*a; a=*&p;
  • 目录 到底什么是指针呢? 指针 指针地址和指针类型 指针取值 ...内存就是一系列有序列号的存储单元,变量就是...指针指向变量的内存地址,指针就像该变量值的内存地址一样 我们来看一个代码片段 func main() { ...
  • 多个指针指向同一个地址

    万次阅读 2017-11-19 20:02:30
    多个指针指向同一个地址,这样使用没什么问题,只是操作时要注意。 因为,每个指针变量保存的值,仅仅是指向的内容的地址值。多个指向同一个地址的指针,若其中一个指针等于NULL,不影响另一个指针。 代码 int* a...
  • 多个指针指向同一个对象

    千次阅读 2015-09-20 21:30:09
    这里是没有问题的,因为p1 和p2 的类型都是person指针类型的,代表将p1的值赋值给p2,而p1的值是对象的地址,所以就把对象的地址赋值给了p2,所以p1和p2指向了同一个对象。 无论通过p1还是p2去修改对象,修改的都是...
  • 关于多指针指向同一块内存的问题

    千次阅读 2017-09-15 15:19:12
    有时为了逻辑实现的方便,在程序中会采用多指针指向同一块内存的设计,但是这同时会带来问题: 问题1:容易引发“野指针”错误!即其中一个指针delete了内存之后,其他指针无法判断该指向地址是否还有效,如果也去...
  • 今天吃饭的路上和同学说起,他说发现了 c 语言中能够通过指针p指向一个int 数组array,然后把指针的值保存为 int 型 变量 address,再对 int 型的指针地址address+4,再把存着数组下一个地址的 int 变量转为 int 型...
  • resultImageToDisp,在主函数里面有个局部变量IplImage* resultImage,我需要将resultImageToDisp赋值给resultImage,但只是浅拷贝,就是说resultImageToDisp和resultImag两个图像指针指向同一内存,主函数结束时按...
  • 1:两个指针指向统一内存,一个指针进行++或者–操作,不会改变另一个指针的指向。 2:释放一个指针such as:free or delete。 另一个指针不会被释放,但不能再访问它指向的内存。
  • #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; int main() { printf("hello main\n"); int N = 1000;... //同一个内存地址只能free一次( free(p1);和free(p2...
  • 理解指针要从变量的地址谈 (1)内存是如何编址的? 内存中的每个字节都有唯一的编号(地址地址按字节编号,其字长一般与主机相同 32位机使用32位地址,最多支持232字节内存(4G) ...
  • 两个指针变量可以相互赋值吗? int *p, *q; p=q; 这样写是什么意思?是p指向q吗? 答:1....3.可以这样写,前提好像是q有确定的地址指向,然后用此语句赋值则表示,指针p和指针q指向相同的地址空...
  • 调试的时候发现一个现象,类型不同指针指向同一内存单元吗?这打印出来的内存地址,是计算机物理内存的实际地址,还是说是程序为每种类型分别分配的一段内存? 如下,信息为同一段程序同一时刻打印: (lldb) ...
  • 指针为什么要区分类型: 在同一种编译器环境下,一个指针变量所占用的内存空间是固定的。比如,在16位编译器环境 下...也就是说,如果不指定指针的类型,那么当指针指向一个变量的时候,她从首地址开始,但是它不知道什么
  • 首先理解指针指向元素与指针,他的意思就相当于地图上你家的位置与你家里的实际情况。知道了**指针**(地图上的位置),就可以知道怎么去你家,但是无法知道你家中的具体情况,而指向元素则涵括了你家里的实际...
  • C++ 多个指针指向同一个对象

    千次阅读 2019-03-16 14:01:36
    多个指针指向同一个对象。当对象被删除时,如果有指针没有被赋值为null,将可能出现不可预期的后果。
  • 摘自三峡大学理学院周鹏 由于在Java中数组实际上是一个类,因此两个数组变量可以指向同一个数组。
  • void DestoryList(ListNode *&L) { ListNode *s,*r; s = L->next; while (s != NULL) ...//不能用这种方法,因为free的机制是使得这部分...答案是不行的,因为free的机制是让该指针变量所指的地址可以随意被调...
  •  让两个指针指向同一块内存,我觉得引发的问题有两点:  (1)很容易引发多次释放同一块内存,俗话说,new和delete要成双成对,当程序庞大时,特别麻烦。即使将演示代码中的释放内存方式1改成如下形式,也是没...
  • c++指针复制指向同一个位置问题

    千次阅读 2015-04-07 14:46:36
    //复制指针时,地址值是可区分的,但指针指向同一基础对象。如果在任一对象上调用 set_ptr_val,则二者的基础对象都会改变 cout *(ptr1.ptr) *(ptr2.ptr); // int *intp = new int(10); HasPtr ptr3(intp, 20);...
  • (三)C语言——指针类型 ...一般把内存中的一个字节成为一个内存单元,不同的数据类型所占用的内存单元数不等。为了正确地访问这些内存单元,必须为每个内存单元编号。根据一个内存单元的编号即可准确地找

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 182,289
精华内容 72,915
关键字:

不同类型指针指向同一地址

友情链接: iodelay-0.4.6-1.tar.gz