C++中野指针问题分析总结

最新推荐文章于 2023-04-27 02:36:14 发布
最新推荐文章于 2023-04-27 02:36:14 发布
阅读量3.5k 收藏 6
点赞数 1
分类专栏： C、C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boyxiaolong/article/details/39437485
版权

其实项目一直被野指针困扰，一直在讨论，居然没有什么下文，下文正式由我接受这个问题。

场景是这样：指针间互相引用，一个被删除的时候，另外一个不知道，它再使用的时候就会异常，因为此时指针已经为空了。

我今天提出的解决方案是：

所以实体都在一个地方管理，其他地方都保存其标识号，每次用的时候根据其标识取就行了，这样看起来最简单，保存的地方我们用hash_map，每次操作O(1)复杂度。

现在觉得还造不成hotpot。

不过刚才在网上，早就有网友遇到类似问题，并做了总结。

知然博友，在“安全编程-c++野指针和内存泄漏”提出的思路跟我的类似：

现在全文引用，备查：

摘要：

　　尽管C++ 野指针和内存泄漏一直被诟病，但是在实时性很强的应用场合，c++ 仍然是不二之选。游戏服务器开发仍然使用c++ 作为主语言，但是大多结合动态脚本技术，一方面规避了野指针和内存泄露，一方面获得了开发效率和扩展性的红利。但脚本技术不是本文的讨论重点，事实上关于c++ 与 lua的技术文章我也一直在整理中，将会另文别述。今天主要说说在使用c++过程中，如何避免和解决野指针和内存泄漏问题。

野指针：

　　野指针的出现会导致程序崩溃，这是每个人都不愿意看到的。Linux会生成coredump文件，可用gdb分析。Win下可以注册unexception获取调用堆栈，将错误信息写到文件中。先分析一下通常出现野指针的场景：

复制代码 
class monster_t
{
protected:
    player_t* m_attack;

public:
    void handle_ai()
    {
        if (m_attack)
        {
            int x = m_attack->get_x();
        }
    }
}
复制代码

 

　　问题就在于，m_attack有值，但是对应的对象已经被销毁了。这是大部分野指针出现原因。分析类之间关系可知，monster_t 和 player_t是0-1的关系，monster_t引用player_t，但是player_t甚至都不知道有一个（或N个）monster 引用了自己。所以当player被销毁时，很难做到把所有引用该player_t的地方全部重置。这种问题其实比较常见，比如player中引用connection，而connection又是被网络层管理生命周期的，也同样容易产生野指针情况。常见的解决方式是：

 

复制代码 
class monster_t
{
protected:
    long m_attack_id;

public:
    void handle_ai()
    {
        player_t* attack = obj_mgr.get(m_attack_id);
        if (attack)
        {
            int x = attack->get_x();
        }
    }
}
复制代码

 

另外一种与之相似的方式：

复制代码 
class monster_t
{
protected:
    player_t* m_attack;

public:
    void handle_ai()
    {
        if (obj_mgr.is_exist(m_attack))
        {
            int x = m_attack->get_x();
        }
        else
        {
            m_attack = NULL;
        }
    }
}
复制代码

 

　　梳理野指针的产生原因后，我们其实需要的是这样的指针：

　　一种指针，引用了另一个对象的地址（不然就不是指针了），当目标对象销毁时，该指针自然指向null，而不需要目标对象主动通知重置。

幸运的是，这种指针已经有了，就是weak_ptr; 在boost库中，sharedptr,scopedptr,weakptr统称为smartptr。可以尽量使用智能指针，避免野指针。本人建议尽量使用shared_ptr结合weak_ptr使用。Scoped_ptr本人使用的较少，只是在创建线程对象的时候使用，正好符合不能复制的语义。使用shared_ptr和weak_ptr的示例代码：

 

复制代码 
class monster_t
{
protected:
    weak_ptr<player_t> m_attack;
    shared_ptr<player_t> get_attack()
    {
        return shared_ptr<player_t>(m_attack);
    }
public:
    void handle_ai()
    {
        shared_ptr<player_t> attack = get_attack();
        if (attack)
        {
            int x = attack->get_x();
        }
    }
}
复制代码

 

有人问monster_t为什么不直接使用shared_ptr，如果使用shared_ptr就不符合现实的模型了，monster_t显然不应该控制player_t的生命周期，如果使用了shared_ptr，那么可能导致player_t被延迟析构，甚至会导致内存暴涨。这也是shared_ptr的使用误区，所以本人建议尽量shared_ptr和weak_ptr结合用，否则野指针问题解决了，内存泄漏问题又来了。

内存泄漏：

野指针问题可以通过采用良好的编程范式，尽量规避，但总计c++规避内存泄漏的方法却很为难，简单而言尽量保证对象的分配和释放（分别）是单个入口的，这样大部分问题都可以拦截在code review阶段。那么怎么检测内存泄漏呢？

首先说明本方法区别于valgrind等工具，该工具是调试期进行的检测，本文探究的是运行期的检测，确切说是运行期定时输出所有对象的数量到日志中。

首先定义分配、释放对象的接口：

复制代码 
template<typename T>
T* new_obj()
{
    T* p = new T();
    singleton_t<obj_counter_t<T> >::instance().inc(1);
    return p;
}

template<typename T, typename ARG1>
T* new_obj(ARG1 arg1)
{
    T* p = new T(arg1);
    singleton_t<obj_counter_t<T> >::instance().inc(1);
    return p;
}

template<typename T, typename ARG1, typename ARG2>
T* new_obj(ARG1 arg1, ARG2 arg2)
{
    T* p = new T(arg1, arg2);
    singleton_t<obj_counter_t<T> >::instance().inc(1);
    return p;
}
template<typename T>
T* new_array(int n)
{
    T* p = new T[n];
    singleton_t<obj_counter_t<T> >::instance().inc(n);
    return p;
}
复制代码

 

为了节省篇幅，这里只列举了三种构造的代码，当分配对象时，对应的类型数量增加1，obj_counter 使用原子操作为每一种类型记录其数量。

复制代码 
class obj_counter_i
{
public:
    obj_counter_i():m_ref_count(0){}
    virtual ~ obj_counter_i(){}
    void inc(int n) { (void)__sync_add_and_fetch(&m_ref_count, n); }
    void dec(int n) { __sync_sub_and_fetch(&m_ref_count, n);        }
    long val() const{ return m_ref_count;                            }

    virtual string get_name() { return ""; }
protected:
    volatile long m_ref_count;
};
template<typename T>
class obj_counter_t: public obj_counter_i
{
    obj_counter_t()
    {
        singleton_t<obj_counter_t<T> >::instance().reg(this);
    }
    virtual string get_name() { return TYPE_NAME(T); }
};
复制代码

 

相应的当对象被释放的时候，对应的对象数量减一，示例代码如下：

复制代码 
template<typename T>
void del_obj(T* p)
{
    if (p)
    {
        delete p;
        singleton_t<obj_counter_t<T> >::instance().dec(1);
    }
}
复制代码

 

这样就做到了所有的对象的数量都被记录了，可以定时的将对象数量输出到文件：

复制代码 
class obj_counter_summary_t
{
public:
    void reg(obj_counter_i* p)
    {
        m_all_counter.push_back(p);
    }

    map<string, long> get_all_obj_num()
    {
        map<string, long> ret;
        for (list<obj_counter_i*>::iterator it = m_all_counter.begin(); it != m_all_counter.end(); ++it)
        {
            ret.insert(make_pair((*it)->get_name(), (*it)->val()));
        }
        return ret;
    }

    void dump(const string& path_)
    {
        ofstream tmp_fstream;
        tmp_fstream.open(path_.c_str());
        map<string, long> ret = get_all_obj_num();
        map<string, long>::iterator it = ret.begin();

        time_t timep   = time(NULL);
        struct tm *tmp = localtime(&timep);

        char tmp_buff[256];
        sprintf(tmp_buff, "%04d%02d%02d-%02d:%02d:%02d",
                tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
                tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
        char buff[1024] = {0};

        snprintf(buff, sizeof(buff), "obj,num,%s\n", tmp_buff);
        tmp_fstream << buff;

        for (; it != ret.end(); ++it)
        {
            snprintf(buff, sizeof(buff), "%s,%ld\n", it->first.c_str(), it->second);
            tmp_fstream << buff;
        }

        tmp_fstream.flush();
    }
protected:
    list<obj_counter_i*>    m_all_counter;
};
复制代码

 

 

输出的文件格式为csv格式，方便进一步做数据分析。可以使用我开发的小工具格式化csv数据。url:http://ffown.sinaapp.com/perf/csv.html

文件内容data:

obj,num,20120606-17:01:41
dumy,1111
foo,222
obj,num,20120606-18:01:41
dumy,11311
foo,2422
obj,num,20120606-19:01:41
dumy,41111
foo,24442

总结：

  • 野指针可以使用shared_ptr和weak_ptr结合使用来尽量规避。
  • 使用shared_ptr要尽量小心，否则可能导致对象无法释放，导致内存泄漏。
  • 可以定时输出当前所有对象的数量，来分析是否有内存泄漏，或者内存泄漏是有哪些对象引起的。
  • 本文介绍了记录所有对象的方法，除了可以分析内存泄漏外，也不失为数据分析的一种方法。需要注明的是，本方法不能替代valgrind工具，二者作用不同。
  • TYPE_NAME 的实现参考

　　https://ffown.googlecode.com/svn/trunk/fflib/include/type_i.h

    全部示例代码：https://ffown.googlecode.com/svn/trunk/fflib/include/obj_tool.h

2、vimer博友提出了用二级指针来管理

C/C++代码中，野指针问题历来已久，当然，大家都知道new/delete要成对出现:

然而现实中却并不是总是如此简单，考虑如下例子:

简单来说，即pA被赋值为NULL，对B中的m_pA没有产生影响，那么怎么才能产生影响呢？
我们有两个做法：
第一种，在A的析构函数里面去B.SetA(NULL)，但是这个相当于A去操作了B的数据，这是不合理的。而且当外面的指针非常多的时候，也根本不可能实现。
第二种方法呢？是的，我们可以用二级指针。
考虑如下代码:

这样确实可以解决野指针的问题，但是同时也引入了另一个问题，那就是ppA本身该什么时候释放呢？答案是：当最后一个引用ppA的类释放掉的时候。
最后一个，对，我们可以使用引用计数！
OK，正式放出我们的代码，其中使用了引用计数来确定当最后一个类释放掉的时候，ppA指针的内存被析构:

我们来写段测试代码测试一下:

输出为:

这个类最有效的使用场景是当出现大量互指指针时，那么指向对象的指针有效性判断就尤其重要，而这个类可以完美解决这个问题。

可能想的比较深的朋友会问，既然引用计数都已经用上了，那么为什么不直接通过引用计数来析构呢？
其实这几天我也在尝试，C++是否能引入完美的引用计数进行对象管理，而最终卡在一个地方，即：

如果，在类的构造函数里面，需要将引用计数对象构造出来，那么引用计数就会出现问题，如:

这个时候就会出现问题，除非把Count构造的计数对象放到一个对象池中管理，但是又会增加对象查找的成本，所以最终放弃了这个想法。
另外一点就是，C/C++的指针在很多情况下是最方便的，过度的封装很可能会弄巧成拙，所以适度就好。

OK，惯例代码还是放到googlecode上：
http://code.google.com/p/vimercode/source/browse/#svn%2Ftrunk%2Fptr_proxy

目前代码使用中没有发现明显问题，欢迎大家交流~

3.还有egmkang网友提出的记录谁引用了自己这个方法：

实现最为简洁：

/*=============================================================================
#
#     FileName: ptr_proxy.h
#         Desc: 这个类的作用，就是为了解决互指指针，不知道对方已经析构的问题
#
#       Author: dantezhu
#        Email: zny2008@gmail.com
#     HomePage: http://www.vimer.cn
#
#      Created: 2011-06-13 15:24:12
#      Version: 0.0.1
#      History:
#               0.0.1 | dantezhu | 2011-06-13 15:24:12 | initialization
#
=============================================================================*/

#ifndef __PTR_PROXY_H__
#define __PTR_PROXY_H__
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <iostream>
#include <memory>
#include <sstream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
using namespace std;

template <typename T>
class ptr_proxy
{
public:
	ptr_proxy(const T* pobj = NULL) : m_ppobj(NULL), m_pcount(NULL)
	{
		if (pobj == NULL)
		{
			return;
		}
		init(pobj);
	}

	ptr_proxy(const ptr_proxy& rhs) // 拷贝构造函数
	{
		m_ppobj = rhs.m_ppobj; // 指向同一块内存
		m_pcount = rhs.m_pcount; // 使用同一个计数值
		add_count();
	}

	virtual ~ptr_proxy()
	{
		dec_count();
	}

	/**
	* @brief   如果指向的对象被释放了，一定要调用这个函数让他知道
	*/
	void set2null()
	{
		if (m_ppobj)
		{
			(*m_ppobj) = NULL;
		}
	}

	/**
	* @brief   赋值函数
	*
	* @param   rhs         源对象
	*
	* @return  自己的引用
	*/
	ptr_proxy& operator=(const ptr_proxy& rhs)
	{
		if (m_ppobj == rhs.m_ppobj) // 首先判断是否本来就指向同一内存块
			return *this; // 是则直接返回

		dec_count();

		m_ppobj = rhs.m_ppobj; // 指向同一块内存
		m_pcount = rhs.m_pcount; // 使用同一个计数值
		add_count();

		return *this; // 是则直接返回
	}

	ptr_proxy& operator=(const T* pobj)
	{
		if (m_ppobj && *m_ppobj == pobj) // 首先判断是否本来就指向同一内存块
			return *this; // 是则直接返回
		dec_count();

		init(pobj);

		return *this;
	}

	/**
	* @brief   获取内部关联的obj的指针
	*
	* @return
	*/
	T* true_ptr()
	{
		if (m_ppobj)
		{
			return *m_ppobj;
		}
		else
		{
			return NULL;
		}
	}

	/**
	* @brief   获取内部关联的obj的指针
	*
	* @return
	*/
	T* operator*()
	{
		return true_ptr();
	}

	/**
	* @brief   获取内部关联的obj的个数
	*
	* @return  个数
	*/
	int count()
	{
		if (m_pcount != NULL)
		{
			return *m_pcount;
		}
		return 0;
	}

	/**
	* @brief   判断智能指针是否为空
	*
	* @return
	*/
	bool is_null()
	{
		if (m_ppobj == NULL || (*m_ppobj) == NULL)
		{
			return true;
		}
		return false;
	}

protected:
	void init(const T* pobj)
	{
		m_ppobj = new (T*)();
		*m_ppobj = (T*)pobj;
		m_pcount = new int(); // 初始化计数值为 1
		*m_pcount = 1;
	}

	void add_count()
	{
		if (m_pcount == NULL)
		{
			return;
		}
		(*m_pcount)++;
	}

	/**
	* @brief   计数减1
	*/
	void dec_count()
	{
		if (m_pcount == NULL || m_ppobj == NULL)
		{
			return;
		}

		(*m_pcount)--; // 计数值减 1 ，因为该指针不再指向原来内存块了
		if (*m_pcount <= 0) // 已经没有别的指针指向原来内存块了
		{
			//我们不去主动析构对象
			//free_sptr(*m_ppobj);//把对象析构
			if (m_ppobj != NULL)
			{
				delete m_ppobj;
				m_ppobj = NULL;
			}

			if (m_pcount != NULL)
			{
				delete m_pcount;
				m_pcount = NULL;
			}
		}
	}

protected:
	T** m_ppobj;
	int* m_pcount;
};

template <typename T>
class IPtrProxy
{
public:
	IPtrProxy() {
		m_ptr_proxy = (T*)this;
	}
	virtual ~IPtrProxy() {
		m_ptr_proxy.set2null();
	}

	ptr_proxy<T>& get_ptr_proxy()
	{
		return m_ptr_proxy;
	}

protected:
	ptr_proxy<T> m_ptr_proxy;
};

#endif



#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <iostream>
#include <memory>
#include <sstream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
#include "test.h"
#include "ptr_proxy.h"
#include <assert.h>
using namespace std;


class object : public referable<object>
{
public:
	int x;
	int test(){ return x; }
};

void test()
{
	object *a = new object;
	object *a1 = new object;
	ref_ptr<object> b = a;
	a->x = 10;
	b->test();
	assert(b && b->x == 10);

	delete a;
	assert(!b);
	b->test();
	b = a1;
	assert(b);
}

int main(){
	test();
}


暂时准备按照自己的想法来做。

xiaolomg
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 中 try catch 的一些
hanyuxinting的专栏
10-18 4393
习惯了在 JS 中写 try catch 语句，所以在c++代码中瞎写。。杯具。我对c++的了解太少了。1.在C++中，很多错误是try{}catch{}捕获不到的，比如空指针访问，野指针访问等，程序都直接崩溃，不会让你捕获的。所以，很遗憾，我惯用try catch，并没有达到预期。2. 绝大多数 windows api 在执行时也并不抛出异常，直接挂掉。还是要对每一个问题做其相应的处理，才不至于挂掉。3. 但可考虑用 GetLastError 获取错误信息。4. 另，考虑到性能问题：在c++程序中，try
基于C语言中野指针的深入解析
09-05
在C语言编程中，野指针是一个非常重要的概念，因为它可能导致程序运行时出现不可预知的错误。野指针并非NULL指针，而是指那些指向已被释放或未初始化内存的指针。这些指针没有指向有效的数据，而是指向了“垃圾”...
野指针和段错误
zeochenyue的博客
12-02 649
野指针：指针指向了一个不确定的地址空间或者是虽然指向了一个确定的地址空间，但是引用这个地址空间 的结果是不可预知的！这样的指针就称为野指针！ 野指针的危害： 1、段错误（其实就是地址错误！） 2、没有结果，现在不会发生错误！这个时候错误很难找出来的！===》要避免野指针！ 3、发生连环错误！循环叠加，莫名其妙的错误！ 野指针产生的原因： 1、使用指针之前没有初始化或者没有指向
内存陷阱 驯服C++中的野指针
fxpopboy的博客
04-07 836
　　什么是野指针？　　一个母亲有两个小孩(两个指针)，一个在厨房，一个在卧室，(属于不同的代码块，其生存期不同)母亲让在厨房的小孩带一块蛋糕(指针指向的对象)给在卧室的小孩，这样在卧室的孩子才肯写作业。但这个在厨房的小孩比较淘气，他在走出厨房时自己将蛋糕吃了，没能带出来。而在卧室的没有吃到蛋糕，所以不肯完成他的作业。结果母亲却不知道卧室的孩子没有吃到蛋糕，还以为作业完了。结果第二天她就被老师召唤到
c++野指针的原理以及避免方法
12-17
1.定义 指向非法的内存地址指针叫作野指针（Wild Pointer），也叫悬挂指针（Dangling Pointer），意为无法正常使用的指针。 2.出现野指针的常见情形 2.1使用未初始化的指针 出现野指针最典型的情形就是在定义指针变量之后没有对它进行初始化，如下面的程序。 #include using namespace std; int main() { int* p; cout<<*p<<endl; //编译通过，运行时出错 } 2.2指针所指的对象已经消亡 指针指向某个对象之后，当这个对象的生命周期已经结束，对象已经消亡后，仍使用指针访问该对象，将
【C++】【异常处理】为什么c++代码里，使用了try-catch后，还是会崩溃
天天向上 Up Up Up (*^▽^*)
07-19 5408
C++的try-catch，和Java、Javascript的异常处理，性质是不一样的 C++的try-catch，只能捕获在代码中主动throw出去的错误 对于空指针，野指针，内存越界等不在预料之中的错误，是没办法捕获的 所以C++的异常机制，更多时候是为了方便处理可预见的异常，对于程序崩溃是没太大效果的 这就是为什么很多人不建议在C++中使用try-catch的原因，它有点用有用，但好像又没太大用，地位比较尴尬 但是C语言是底层语言，很多时候都是直接和内存打交道 出了致命问题，就算程序不崩溃，再继续运行
靶场外弹道数据处理中野值点剔除方法.pdf
08-15
#资源达人分享计划#
HPLC法测定小花棘豆中野决明碱含量的研究 (2008年)
05-20
目的建立小花棘豆中主体毒性物质野决明碱含量的HPLC测定方法。方法采用高效液相色谱法，色谱柱：ODS-C18（250mm×4.0mm，5μm）；柱温为30℃。流动相A：甲醇，流速为0.4mL?min-1；流动相B：0.5%柠檬酸钠+0.5%...
高斯牛顿迭代法matlab代码-pnpfr_problem:ECCV2016论文“解决PnP，PnPf和PnPfr问题的通用方法”的官方MAT
05-24
高斯牛顿继承法matlab代码解决PnP，PnPf和PnPfr问题的多功能方法 :copyright:2020 NEC公司 该存储库是ECCV2016论文“解决PnP，PnPf和PnPfr问题的通用方法”的官方MATLAB实现。 代码中使用的Gröbner基求解器由V. ...
【C++】野指针及其危害
L19002S的博客
11-21 5557
【C++】野指针及其危害 引言：小白在初期敲代码时最可能碰到的问题之一估计就是野指针了，因为它在写程序的时候一不注意就写出来了，且不容易被发现，调试半天可能也不会出结果。去找大佬一看，其实就是一个很简单的野指针问题，那么我们今天就来学习一下关于野指针的问题，以及怎么在敲代码时如何规避它。 什么是野指针呢？ 答：“野指针”并不是NULL指针，而是在定义上没有初始化，值为随机，又或者是指向了已经被释放...
段错误和野指针，关键词及内存管理
ZEROJOKEROOO的博客
06-09 314
野指针和段错误；什么叫野指针： p保存的是int a的地址，那么就说 p指向a; 1、当指针指向不明确的时候； int *p; //此时不知道p保存的是什么地址！ *p = 10; 2、指针保存的地址不存在！ int *p = 0x12345678; 2、指针指向明确，地址也存在，但是我们指向的空间没有操作权限； int *p = NULL; //指向了0地址；但是0地址受系统...
会出现段错误的几种情况
嵌入式学习之栏
07-21 2561
（1）、使用了野指针
C++ 野指针
weixin_45925735的博客
04-27 951
所谓野指针(wild pointer)，简单讲是指指向不可用的内存区域的指针。需要注意的一点是，野指针与NULL空指针是不同的。NULL指针一般比较好判断，直接用if (p==NULL)语句判断即可。但是野指针是指向垃圾内存区域的指针，野指针会指向一段实际的内存，只是它指向哪里我们并不知情，或者是它所指向的内存空间已经被释放，所以在实际使用的过程中，我们并不能通过指针判空去识别一个指针是否为野指针。避免野指针只能靠我们自己养成良好的编程习惯。
C++的内存泄漏与野指针
sinat_31608641的博客
08-24 1082
一、定义 野指针：访问一个已销毁或者访问受限的内存区域的指针，野指针不能判断是否为NULL来避免 悬垂指针：指针正常初始化，曾指向一个对象，该对象被销毁了，但是指针未置空，那么就成了悬空指针。结果未定义，往往导致程序错误，而且难以检测 二、野指针产生的原因 1.指针定义时未被初始化：指针在被定义的时候，如果程序不对其进行初始化的话，它会随机指向一个区域，因为任意指针变量（出了static修饰的指针）它的默认值都是随机的 2.指针被释放时没有置空：我们在用malloc（）开辟空间的时候，要检查返回值
野指针崩溃原因
佛道教主
11-15 1519
野指针问题可能会立即崩溃也可能不会立即崩溃
C++中野指针如何表示
最新发布
06-06
C++中野指针通常是指未初始化或未赋值的指针，或者指向已经释放的内存的指针。由于野指针指向的地址是不确定的，因此在使用时可能会产生不可预知的后果，包括程序崩溃、访问非法内存等。 在代码中，野指针通常会被赋值为一个未知的地址，或者被使用前没有经过初始化。例如： ``` int* p; // 未初始化的指针，可能是野指针 *p = 10; // 使用野指针，可能会导致程序崩溃或者访问非法内存 ``` 另外，当我们释放一个指针指向的内存后，如果没有将指针设置为 NULL 或者 nullptr，那么指针就变成了野指针，因为它指向的内存已经被释放。例如： ``` int* p = new int(10); delete p; *p = 20; // p 变成了野指针，可能会导致访问非法内存 ``` 因此，在使用指针时，应该尽可能避免产生野指针，避免不必要的风险。如果必须使用指针，要确保指针指向的内存是合法的，并且在使用前进行正确的初始化或者赋值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值