void指针怎么释放（c/c++怎么用free释放二级指针）

本文目录

• c/c++怎么用free释放二级指针
• c++队列元素含指针怎么释放
• C++ 函数返回指针的释放问题，如何释放
• C++动态内存在函数中释放
• 怎么释放vector容器中的指针
• C++ void* 托管指针能正确释放内存吗
• void类型的函数怎么结束
• C语言中是如何释放内存单元的；原理又是什么
• C语言如何释放指针
• C++指针内存释放问题

c/c++怎么用free释放二级指针

#include 《string.h》
#include 《stdio.h》
#include 《malloc.h》

#define BOOL int
#define FALSE 0
#define TRUE 1

BOOL GetStrBuf(char **ppBuf, int nLen)
{
(*ppBuf) = (char *)malloc(nLen * sizeof(char));

return ((NULL == (*ppBuf)) ? FALSE : TRUE);
}

void FreeStrBuf(char **ppBuf)
{
if (NULL != (*ppBuf))
{
free((*ppBuf));
(*ppBuf) = NULL;
}
}

int main(void)
{
char *pBuf = NULL;
char *pData = "Hello, wrold !";
int nLen;
BOOL bRet;

nLen = strlen(pData);

// get buf for pBuf
bRet = GetStrBuf(&pBuf, nLen+1);

// if get buffer fail
if (!bRet)
{
printf("malloc for string buf fail !/n");
return -1;
}
// clear the buffer for copy
memset(pBuf, 0, nLen+1);

strncpy(pBuf, pData, nLen);
printf("pData is: %s/n", pData);
printf("pBuf is: %s/n", pBuf);

// free had malloc mem buf
FreeStrBuf(&pBuf);
// then the pBuf = NULL, 0x0

return 0;
}

c++队列元素含指针怎么释放

#pragma once //用数组实现的循环队列//SeqQueue.h#include "stdafx.h"#include "Windows.h"#include "stdlib.h"#include "iostream.h"template《class T》class SeqQueue{private: T *queue; int front,rear,MaxSize;public: SeqQueue(int sz=30);//构造函数 SeqQueue(SeqQueue& sq);//拷贝构造函数 SeqQueue(int arraysz,T *a,int sz=30);//构造函数 void MakeEmpty();//清空队列 bool IsEmpty();//队列是否为空 int GetLength();//获得长度 int GetMaxSize();//获得队列大小 T &GetFront();//获得队首元素 bool EnQueue(T &x);//入队 bool OutQueue(T &x);//出对 void show(); ~SeqQueue();//析构函数}; template《class T》SeqQueue《T》::SeqQueue(int sz){ queue=new T; rear=(rear+1)%MaxSize; }} template《class T》void SeqQueue《T》::MakeEmpty(){ front=rear=0;} template《class T》bool SeqQueue《T》::IsEmpty(){ return front==rear;} template《class T》int SeqQueue《T》::GetLength(){ return ((rear-front)+MaxSize)%MaxSize;} template《class T》int SeqQueue《T》::GetMaxSize(){ return MaxSize;}

C++ 函数返回指针的释放问题，如何释放

func这样写的话，就是要求调用func的函数来释放p
因为func在main中被调用，而又main来释放，没有问题
因为free语句是main的最后一句，就算不写，程序结束的时候也会自动回收
不过其他场合，只要程序不终结，就必须手动free掉，不然内存就泄漏了
main里面的s是什么东西，应该用不着吧

C++动态内存在函数中释放

可以，你要把指针保存起来！
很简单啊，你要是声明为函数内局部，你就在函数里释放；
你一定要在函数外释放的话，把指针声明在类中，造构时置NULL，在函数中检测不为NULL则分配。在析构中，不为NULL就释放，释放完记得再置NULL！或专门定义一个释放它的函数，在析构中调用！这方法很常用！
还可以用参数来返回！反正就是，你想在函数外完成释放，就应该在函数外有一个指针，然后函数内必须可以操作这个指针，对它进行分配内存等等，不管你是怎么传它到函数里！
//这种写法没见过！
char fok()
{
return new char(’a’);
}

怎么释放vector容器中的指针

　　调用clear清楚容器中的指针的时候，系统会自动释放指针所指的对象，用不着程序员操作。就你的具体问题摘了段STL源码。注释过了，应该能看懂。
　　void clear() { erase(begin(), end()); } iterator erase(iterator first, iterator last) { iterator i = copy(last, finish, first); destroy(i, finish);// 全局函数，销毁元素的基本函数。 finish = finish - (last - first); return first; }// 以下是 destroy() 第二版本，接受两个迭代器。// 这里用到了traits技术，判断型别，以便用不同的方式析构对象，不了解traits略过就可以template 《class ForwardIterator》inline void destroy(ForwardIterator first, ForwardIterator last) { __destroy(first, last, value_type(first));}// 判断元素的数值型别（value type）是否有 trivial destructortemplate 《class ForwardIterator, class T》inline void __destroy(ForwardIterator first, ForwardIterator last, T*) { typedef typename __type_traits《T》::has_trivial_destructor trivial_destructor; __destroy_aux(first, last, trivial_destructor());}// 如果元素的数值型别（value type）有 non-trivial destructor…对应与类，此时无法直接大块释放内存// 当为内置数值如int等，可以直接大片释放内存来提高效率template 《class ForwardIterator》inline void__destroy_aux(ForwardIterator first, ForwardIterator last, __false_type) { for ( ; first 《 last; ++first) destroy(&*first); //这里是一个指针，也就是你容器中的元素}// 以下是 destroy() 一个版本，接受一个指针。template 《class T》inline void destroy(T* pointer) { pointer-》~T();// 使用析构函数，}

C++ void* 托管指针能正确释放内存吗

CSonType* son = new CSonType;
void *pVoid = son;
delete pVoid;

无论是否托管代码，将对象指针赋给无类型指针void*，c++在释放掉这个对象时，不会针对对象内动态分配的内存做任何释放操作。哪怕析构函数是虚函数，   也不会被调用

// 正确的释放内存方式
CFatherType* pFather = (CFatherType *) pVoid;
delete pFather;

将这个无类型指针转而赋值给CFatherType*，编译器知道了具体的对象类型，才能针对性进行对象内部分配的动态内存进行释放。

只有对对象指针进行delete操作，C++才会自动调用对象的析构函数。

如果满意，欢迎采纳，谢谢

如有疑问，欢迎追问

void类型的函数怎么结束

1、直接使用return;语句就可以了。

void类型函数只是没有返回值，不代表不能使用return返回。

2、return表示中止当前函数的运行，并将操作权返回给调用者。

如果是在main函数中，表示将操作权返回给操作系统，return 不是必须要返回一个值。当然，就算不写return，在函数执行完毕后也会返回操作权给调用者。

扩展资料：

void关键字的使用规则：

1、如果函数没有返回值，那么应声明为void类型

在C语言中，凡不加返回值类型限定的函数，就会被编译器作为返回整型值处理。

2、如果函数无参数,那么应声明其参数为void

3、小心使用void指针类型

按照ANSI(American National Standards Institute)标准，不能对void指针进行算法操作。

C语言中是如何释放内存单元的；原理又是什么

C管理内存大致可以理解为两种，分配在栈上的，一个是分配在堆上的。

临时变量，动态变量，分配在栈上，运行完，直接弹出栈，就没了。
分配在堆上的内存，释放的时候，基本上可以理解为，指针不指这里了。也就失去了对这块内存的控制。其实所谓的释放。字面意思容易让人理解错。
有些机器有些操作系统，会在释放的时候清空这段内存，但是这种做法效率不高，但是安全，很少有机器这么做，多数都是所谓释放，就是不让你控制这块内存了而已。

C语言如何释放指针

C语言中可以使用free函数释放指针。
1、free函数：
原型：void
free(void
*ptr)；
功能：释放malloc(或calloc、realloc)函数给指针变量分配的动态内存。
2、为了避免释放已经释放了内存的指针内存，或没有释放内存，在C语言中最好是在定义指针时赋初值NULL，释放后立即赋NULL，释放时检查指针值再决定释放就避免释放错误了，例如：
int
*a
=
NULL
int
*b
=
(int*)
malloc(sizeof(int)
*
10);
a=
b;
/*
执行大量操作后
*/
if(a
!=
NULL)
{free(a);a=NULL;}
if(b
!=
NULL)
{free(b);b=NULL;}

C++指针内存释放问题

C++中指针在new和delete操作的时候对内存堆做的如下
1、指针的new操作：
指针在new之后，会在内存堆中分配一个空间，而指针中存放的是这个空间的地址。如：
void main(){
int *p = new int(4);
cout 《《 p 《《 endl;
cout 《《 *p 《《 endl;
}
输出为：
0x00431BF0
4
分别为分配的空间地址和地址内存放的值。
如果写为：
void main(){
int *p = new int(4);
cout 《《 *(int *)0x00431BF0 《《 endl;
}
输出为：4
程序的意思就是将0x00431BF0内存地址开始的4个byte的块取出转换为int类型输出，即直接读取内存。
2、指针的delete操作：
指针在delete的时候，会将指针指向的内存区域释放掉，而指针同内存区域的联系并没有被切断，仍然会只想原来指向的内存区域。如：
void main(){
int *p = new int(4);
cout 《《 p 《《 endl;
cout 《《 *p 《《 endl;
delete p;
cout 《《 p 《《 endl;
cout 《《 *p 《《 endl;
}
程序输出：
0x00431BF0
4
0x00431BF0
-572662307
可以看到p前后指向的地址是相同的，而指向地址的内存区域被释放。
3、空指针：
空指针指向的内存区域为内存的首地址，是不可读写的区域，即空指针不提供操作。删除空指针是安全的(因为它什么也没做)。所以，在写构造函数，
赋值操作符，或其他成员函数时，类的每个指针成员要么指向有效的内存，要么就指向空，那在你的析构函数里你就可以只用简单地delete 掉他们，而不用
担心他们是不是被new 过。如：
void main(){
int *p = NULL;
cout 《《 p 《《 endl;
} //输出0x00000000
4、取出内存区域的值
在取某内存地址开始的一个区域的值的时候，取出的值取决于用来取值的类型，譬如int为4个byte，char为1个byte，程序如：
void main(){
int a = {261,0};
int *pi = a;
char *p = (char*)pi;
cout 《《 *(int *)p++ 《《 endl; //取出p地址，转化为取4个byte，并取出内容，之后p向后移动一位
cout 《《 *(int *)p 《《 endl; //取出p地址，转化为取4个byte，并取出内容
cout 《《 (int)*p 《《 endl; //取出1个char类型，并转换为int型
cout 《《 (int)*(char *)pi 《《 endl; //取出pi地址，转换为char类型，取出内容，并转换为int型
}
程序输出：
261
1
1
5
a的存储区域安排为：byte1=5,byte2=1,byte3~byte8 = 0;
所以*(int *)p++取的为byte1到byte4； 之后的*(int *)p取的是byte2到byte5；
(int)*p取的是byte2；(int)*(char *)pi取的是byte1，之后转换为int型。