alloca的运用

最新推荐文章于 2023-10-07 13:58:29 发布
置顶 最新推荐文章于 2023-10-07 13:58:29 发布
阅读量1.8k 收藏
点赞数 1
分类专栏： C++ 文章标签： alloc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adi_1987/article/details/53463855
版权
这篇文章是讲alloca实现的原理。 alloca我感觉是个很强大的函数，帮了我一个很大的忙。突然觉得我就是个天才，我们知道，构造一个对象，无非就二种方式，一种形式就是动态构造：
class A;
A* a=new A();
对于这种形式，编译器底层可能是这么实现的：
size_t   nClassSize=sizeof(A);
void*    pClassAdress=malloc(nClassSize);
return new(pClassAdress)A();
一种就是静态构造，
class A;
A a;
同样对于这种方式，编译器底层可能是这么实现的：
size_t   nClassSize=sizeof(A);
void*    pClassAdress=alloca(nClassSize);
return new(pClassAdress)A();

这里用到new的一种新用法，new(void* pAddress)Construct();
这句话的作用其实是在pAddress所指向的内存上调用类的构造函数来初始化pAddress指向的内存，构造出指定对象。很多内存池技术会用这种方式来在内存池缓存中构造对象。
上面二种方式中，唯一不同的就是内存分配函数不同。
malloc是在堆上分配内存，其分配，回收都会跟操作系统打交道，一来速度会很慢，二来频繁的调用会导致很多内存碎片，更加导分配性能的下降。对于这种方式分配的内存需要显示调用free函数来回收内存，以防造成内存泄露。
而alloca这个函数的不同之处在于：该函数是在调用堆栈上来分配内存：在调用堆栈上分配内存有什么不一样呢？其实调用堆栈的分配，回收只是CPU寄存器的ESP的移动，基本上只需要几十条机器指令就能实现一次分配：而且不需要人为的释放，不会造成内存泄露：
_alloca_probe_16 proc                   ; 16 byte aligned alloca  
push    ecx  
lea     ecx, [esp] + 8          ; TOS before entering this function  
sub     ecx, eax                ; New TOS  
and     ecx, (16 - 1)           ; Distance from 16 bit align (align down)  
add     eax, ecx                ; Increase allocation size  
sbb     ecx, ecx                ; ecx = 0xFFFFFFFF if size wrapped around  
or      eax, ecx                ; cap allocation size on wraparound  
pop     ecx                     ; Restore ecx  
jmp     _chkstk  
更重要的是，函数的调用堆栈是程序启动时，就已经分配好的内存，在调用堆栈上分配内存是不需要再跟操作系统打交道的，性能非常高，而且不会造成内存碎片。
这个函数简直帮了我的大忙，帮我优化了不少性能。我之前设计了一套网络通信库，希望实现拾取到网络消息后，根据包ID，构造出逻辑包，初始化逻辑包的数据，调用逻辑包的处理函数；
class Packet
{
private:
uint32_t    m_peerIP;
int32_t     m_SocketID;
public:
void SetPeerIP(uint32_t IP){m_peerIP=IP;}
void SetSocketID(int32_t Id){m_SocketID=Id;}
uint32_t GetPeerIP(){return m_peerIP;}
        int32_t  GetSocketID(){return m_SocketID;}
Packet():m_peerIP(0),m_SocketID(0){}
virtual ~Packet(){CleanUp();}//这里基类的析构函数一定要用虚函数
        virtual void CleanUp(){};
virtual bool Read(CMessage& Ref)=0;
virtual bool Write(CMessage& Ref)=0;
virtual int Execute()=0;
virtual PacketID GetPacketID()=0;
};
class PacketFactory 
{
public :
PacketFactory(){}
virtual ~PacketFactory(){}
        virtual Packet* CreatePacket(void* pAddress)=0;
        virtual PacketID GetPacketID()const=0;
virtual int         GetPacketSize()=0;
};
上面二个类Packet是逻辑包基类，PacketFactory是逻辑包工程类，通过这个工厂能够构造出逻辑包，CMessage是个消息包其底层是基于二进制流的。
class PacketMgr :public Singleton<PacketMgr>
{
friend class CMessage;
private:
PacketFactory**    m_Factories;
    unsigned int       m_Size;
bool               b_Inited;//是否已经初始化
public:
PacketMgr():b_Inited(false),m_Size(0),m_Factories(NULL){}
virtual ~PacketMgr()
{
for(unsigned int i=0;i<m_Size;i++)
{
SAFE_DELETE(m_Factories[i]);
}
SAFE_DELETE_ARRAY(m_Factories);
b_Inited=false;
m_Size=0;
}
bool  AddFactory(PacketFactory* pFactory)
{
if(b_Inited==false)
{
assert(false);
return false;
}
if(pFactory==NULL)
{
return false;
}
int nPackIdx=pFactory->GetPacketID();
if(nPackIdx<0||nPackIdx>=m_Size)
{
return false;
}
if( m_Factories[nPackIdx]!=NULL) 
{
assert(false);
return false;
}
m_Factories[nPackIdx]=pFactory;
return true;
}
private://这两个函数仅提供给CMessage对象来用
Packet*  CreatePacket(PacketID nId,void* pAddress)
{
if(nId>=m_Size ||nId<0 || m_Factories[nId]==NULL||pAddress==NULL) 
{
assert(false);
return NULL;
}
Packet* pPacket=m_Factories[nId]->CreatePacket(pAddress);
return pPacket;
}
void     RemovePacket(Packet* pPacket)
{
//pPacket所指向的内存由栈管理，无需delete,仅需调用对象的析构函数
if(pPacket==NULL)
{
assert(false);
return;
}
pPacket->~Packet();//此处析构函数为虚函数，会先调用子类对象的析构函数，然后再调用父类函数的析构函数，防止内存泄露
}
public:
int      GetPacketSize(PacketID nId);
bool     Init(int nMaxPacket)
{
assert(nMaxPacket>0);
m_Size=nMaxPacket;
m_Factories=new PacketFactory*[m_Size];
for(unsigned int i=0;i<m_Size;i++)
{
m_Factories[i]=NULL;
}
b_Inited=true;
return true;
}
};
}
#define S_PACKET_MGR  (PacketMgr::Instance())
PacketMgr是一个逻辑包管理类，系统初始化时，会调用AddFactory以逻辑包ID为数组下标，将逻辑包工厂类添加到m_Factories数组。
S_PACKET_MGR- AddFactory(new  CGLoginFactory() );
一个简单的逻辑包实现：
class CGLogin : public Packet
{
private:
char          m_Account[MAX_ACCOUNT_LEN];//账号
char          m_Pwd[MAX_PWD_LEN];//密码
uint32_t      m_ClientVersion;//客户端版本
public:
CGLogin();
~CGLogin();
void SetAccount(const char* szAccout);
const char* GetAccount(){return m_Account;}
void        SetPwd(const char* szPwd);
const char* GetPwd(){return m_Pwd;}
uint32_t    GetClientVersion(){return m_ClientVersion;}
void        SetClientVersion(uint32_t version){m_ClientVersion=version;}
public:
virtual void CleanUp();
virtual bool Read(CMessage& Ref)
{
Ref.getEx((void*)m_Account,sizeof(m_Account));
Ref.getEx((void*)m_Pwd,sizeof(m_Pwd));
m_ClientVersion=Ref.getUInt32();
}
virtual bool Write(CMessage& Ref)
{
Ref.addEx((void*)m_Account,sizeof(m_Account));
Ref.addEx((void*)m_Pwd,sizeof(m_Pwd));
Ref.addUInt32(m_ClientVersion);
}
virtual int Execute()
{
    return CGLoginHandler::Execute(this);
}
virtual PacketID GetPacketID(){return CG_Login;}
};
class CGLoginFactory : public PacketFactory 
{
//注意这里new的用法 new(void* p)fun();这里new的作用是在p所指向的内存调用对象的构造函数，不会再申请内存
Packet* CreatePacket(void* pAddress){ return new(pAddress)CGLogin();}
PacketID GetPacketID()const{ return CG_Login;}
virtual int         GetPacketSize(){return sizeof(CGLogin);}
};
class CGLoginHandler 
{
public:
static int Execute(CGLogin* pPacket) ;
};
//网络底层拾取屌网络消息，回来调用消息的run方法。
int32_t CMessage::run()
{
uint32_t packet_id = getMsgID();
size_t PacketSize=S_PACKET_MGR->GetPacketSize(packet_id);
if(PacketSize<=0)
{
return 0;
}
//alloca函数用于在栈上申请指定大小的内存空间，其申请的内存空间由栈负责回收
void* pAddress=NULL;
#if  _WIN32
        __try
#else
try
#endif
{
pAddress=alloca(PacketSize);//在栈上申请对象大小的空间，用于构造对象
}
#if  _WIN32
__except(EXCEPTION_EXECUTE_HANDLER)
{
             pAddress=NULL;
}
#else
catch(...)
{
pAddress=NULL;
}
#endif
bool bAllocInStack=false;//是否在栈上分配的内存
if(pAddress==NULL)
{
//如果在栈上分配失败则在堆栈上分配
pAddress=malloc(PacketSize);
bAllocInStack=false;
}
else
{
bAllocInStack=true;
}
if(pAddress==NULL)
{
assert(false);
return 0;
}
memset(pAddress,0,PacketSize);//初始化这块内存
Packet* pPacket=S_PACKET_MGR->CreatePacket(packet_id,pAddress);//在指定的地址上构造包对象
//这里pPacket的地址实际上是pAddress的地址,上面已经判断过pAddress的值，这里无需再判断pPacket是否为空了
pPacket->SetSocketID(m_socketID);
pPacket->SetPeerIP(m_dwIP);
pPacket->Read(*this);//初始化逻辑包
int nRet=pPacket->Execute();//调用逻辑包处理函数
S_PACKET_MGR->RemovePacket(pPacket);//该函数仅会调用类的析构函数,并不会delete pPacket指向的内存，该内存分配在栈上，由系统负责回收
if(bAllocInStack==false)
{
//内存是分配在堆栈上，需要手动释放内存
free(pAddress);
}
return nRet;
}
}
bool SendPacket(Packet* pPacket)
{ if(pPacket==NULL)
{
return false;
}
int nPacketId=pPacket->GetPacketID();
CMessage Msg;
Msg.init(nPacketId);
pPacket->Write(Msg);//将逻辑包的数据写入消息流
//调用网络底层将CMessage发送出去
}
adi_1987
关注
专栏目录
C语言的_alloca原理,【动态分配栈内存】之alloca内幕
weixin_42522912的博客
05-24 798
哎，下班回家就开始大扫除，一直到凌晨才搞定，真的累了。但是计划的是今天必须将本文写完，不写完睡不着觉。那就尽快切入正题吧！我们经常使用malloc或者new等函数或操作符来动态分配内存，这里的内存说的是堆内存，并且需要程序员手工释放分配的内存。malloc对应free，new对应delete。至于你要混着用，也不是不可以，只要确保逻辑和功能的正确性，还要在规范的限制范围内。这里我想插一句题外话，我...
【C语言】动态内存管理。alloca、calloc、malloc、free、realloc是什么？动态内存开辟的常见使用错误
m0_49425260的博客
09-25 678
本篇文章旨在简单介绍动态内存管理的四个主要的函数，其次我们会通过一些代码演示一些使用时的常见错误，帮助读者加深动态内存管理的这四个函数。本篇文章我们介绍了alloca、calloc、malloc、free、realloc这四个函数的基本用法，以及在使用这些函数时，我们可能遇到的常见错误。如果本文有错误，欢迎各位大佬指正（玻璃心，轻喷）最后祝大家学习进步，功不唐捐！
【动态分配栈内存】之alloca内幕
soboer
09-30 683
哎，下班回家就开始大扫除，一直到凌晨才搞定，真的累了。但是计划的是今天必须将本文写完，不写完睡不着觉。那就尽快切入正题吧！ 我们经常使用malloc或者new等函数或操作符来动态分配内存，这里的内存说的是堆内存，并且需要程序员手工释放分配的内存。malloc对应free，new对应delete。至于你要混着用，也不是不可以，只要确保逻辑和功能的正确性，还要在规范的限制范围内。这里我想插一句题外...
alloca() 是什么？为什么不提倡使用它？
jfkidear的专栏
01-06 1180
alloca() 是什么？为什么不提倡使用它？ 在调用 alloca() 的函数返回的时候, 它分配的内存会自动释放。也就是说, 用 alloca 分配的内存在某种程度上局部于函数的 ``堆栈帧"  或上下文中。 alloca() 不具可移植性, 而且在没有传统堆栈的机器上很难实现。 当它的返回值直接传入另一个函数时会带来问题, 如  fgets(alloca(100), 100, stdin
关于alloca()函数
yasi_xi的专栏
06-19 3213
转自： http://mqjing.blogspot.com/2008/07/c-alloca.html http://stackoverflow.com/questions/1018853/why-is-alloca-not-considered-good-practice
alloca
wuguinianjing的博客
11-05 364
_alloca是在栈(stack)上申请空间,用完马上就释放. 在C99标准之前，C语言是不支持变长数组的，如果想要动态开辟栈内存以达到变长数组的功能就得依靠alloca函数。其实在gcc下，c99下的变长数组后台也是依靠alloca来动态分配栈内存的，当然这里不能完全说是调用alloca来实现的，alloca可能被优化并内联（当然你还是可以说这是在调用） alloca不具可移植性, 而且在没有传统堆栈的机器上很难实现。当它的返回值直接传入另一个函数时会带来问题,因为他分配在栈上. 由于这些原因, allo
AVR.zip_avr_iom1284p.h
09-24
《AVR单片机开发中的头文件解析》 在嵌入式系统开发中，AVR单片机以其高效能和低功耗的特性被广泛应用。...在实际开发过程中，理解和熟练运用这些头文件及其提供的函数，是提升代码质量和效率的关键。
leetcode总结1
08-08
在编程领域，尤其是在C++...总之，理解堆和栈的特性并适时运用是每个C++程序员的基本技能，这对于编写高效、健壮的代码至关重要。在解决实际问题时，结合这两种内存管理方式的优势，能够更好地解决问题并优化程序性能。
在PB中得到网卡号及IP地址
03-26
总的来说，在PowerBuilder中获取网卡号和IP地址涉及到对Win32 API的熟练运用，理解网络接口的基本概念，以及对IP协议的理解。通过封装API调用，可以在PB应用程序中轻松获取并处理这些网络信息，从而实现各种网络相关...
EW430_IAR_C_LIB.rar_IAR C LIBRARY
09-21
1. **内存管理**：IAR C库提供了动态内存分配和释放的函数，如`malloc()`和`free()`，以及静态内存区域的管理，例如`alloca()`。这些函数对于创建和销毁数据结构至关重要。 2. **输入/输出（I/O）**：库中包含了...
《c专家编程》笔记--alloca函数
TODD911的专栏
04-14 1658
alloca()函数用来在栈中分配size个字节的内存空间，因此函数返回时会自动释放掉空间。alloca函数定义及库头文件如下： /* Allocate a block that will be freed when the calling function exits.  */extern void *alloca (size_t __size) __THROW;   //从栈
[pwnable.kr]--alloca
weixin_30394251的博客
08-14 195
0x00: 好久没玩了...去年十月以后就没玩过了TAT 这几天把peach的坑，winafl的坑填了下，就来搞下pwn。 0x01: 这个程序是给了源码的 #include <stdio.h> #include <string.h> #include <stdlib.h> void clear_newlines(){ int c; do{ ...
基于栈的内存非配--alloca函数
最新发布
qq_36554461的博客
10-07 2328
alloca是一个在 C 和 C++ 中可用的函数，用于在栈上动态分配内存空间。它类似于malloc函数，但是分配的内存空间在函数返回后会自动释放，无需显式调用free函数。以下是alloca函数的详细介绍：sizeallocaallocaallocamemsetalloca使用alloca上述示例中，alloca函数用于在函数中动态分配一个包含 10 个int类型元素的数组。然后，数组被初始化并打印出来。在函数返回后，分配的内存空间会自动释放，无需手动释放。需要注意的是，由于alloca。
【pwnable.kr】 alloca
子曰小玖的博客
06-10 760
https://www.anquanke.com/post/id/170288 前言 最近在刷pwnable.kr [Rookiss]，题目都好有意思，一其中题alloca虽然分值不高，但分析过程很值得学习。 题目描述 Let me give you a lesson: "How to prevent buffer overflow?" ssh alloca@pwnable....
关于_alloca
09-27 3210
今天发现_alloca可以代替linux下的动态数组的定义，所以网上搜了下，归结如下：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝使用_alloca的一个Demo// 感谢[迷迷糊糊]提供_alloca我知// _alloca的功能是在栈上动态分配空间// 在栈空间不足的情况下会产生SEH异常，需要__try保护// 不能对同一段代码同时
alloca 函数
a3121772305的博客
02-09 1037
alloca 函数是一个内存分配函数，与malloc、calloc、realloc类似，但是注意一个重要的区别：alloca 是在栈(stack)上申请空间的，并且用完马上就释放。
C语言 alloca函数
almostlover__的博客
06-04 2259
alloca()函数申请的是栈空间，所申请的空间在函数结束后会自动释放，但是栈的大小有上限，因此该函数有可能导致栈溢出，使得程序崩溃，在Visual Studio中可以设置程序的栈区的大小上限。
c _alloca 函数的实现
cncnlg的专栏
03-19 1961
_alloca 函数的实现 C 语言里有一个 alloca 函数，可以在堆栈上分配一块内存，当前函数退出时，由于系统堆栈指针的调整，这块内存会被自动回收。 alloca 的函数原型是 void * alloca(size_t size); 今天，在各种编程文档中已经不太提倡使用了。因为它有许多不安全因素。这里暂且不讨论。 另外，在 CRT 库里，通常还会提供一个 _alloca
alloca怎么获取内存
06-01
`alloca()` 函数是用来在栈上分配内存的，其原型为 `void *alloca(size_t size)`，它接受一个 `size` 参数，表示要分配的内存大小，单位为字节。`alloca()` 函数会在栈上分配一块连续的内存空间，并返回一个指向该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值