VS 2010 CRT ::operator new源码分析

最新推荐文章于 2022-05-11 10:49:38 发布
最新推荐文章于 2022-05-11 10:49:38 发布
阅读量742 收藏 1
点赞数
分类专栏： VS CRT 文章标签： VS CRT new operator 源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiQian06336/article/details/99290620
版权

从我们写代码说起

C++面试常见的一个问题是：new与malloc的区别，然后你去网上搜索这个问题，常见回答如下：

malloc : 只能单独给对象申请空间，不能进行构造函数的调用

new :  不仅能申请动态空间，还能调用构造函数进行对成员变量初始化

我们此篇文章对哪一块源码分析呢？对，就是对new的分配内存的那部分源码进行分析。::operator new这是一个重载，重载的功能就只是分配内存，而调用构造函数在分配后的内存进行初始化，那是编译器的工作。而既有分配内存，又能在内存处初始化的功能叫做new operator。

源码分析

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
        {       // try to allocate size bytes
        void *p;
        while ((p = malloc(size)) == 0)
                if (_callnewh(size) == 0)
                {       // report no memory
                static const std::bad_alloc nomem;
                _RAISE(nomem);
                }

        return (p);
        }

上面这个就是operator new,主要就是调用一个malloc，若调用不成功，调用_callnewh

extern "C" int __cdecl _callnewh(size_t size)
{
        {
            _PNH pnh = (_PNH) DecodePointer(_pnhHeap);

            if ( (pnh == NULL) || ((*pnh)(size) == 0) )
                return 0;
        }
        return 1;
}

_pnhHeap是我们在_set_new_handler函数里面EncodePointer进来的。然后调用一下我们自己的new失败处理函数。回到malloc。malloc函数里又调用了_nh_malloc_dbg

extern "C" void * __cdecl _nh_malloc_dbg (
        size_t nSize,
        int nhFlag,
        int nBlockUse,
        const char * szFileName,
        int nLine
        )
{
        int errno_tmp = 0;
        void * pvBlk = _nh_malloc_dbg_impl(nSize, nhFlag, nBlockUse, szFileName, nLine, &errno_tmp);

        if ( pvBlk == NULL && errno_tmp != 0 && _errno())
        {
            errno = errno_tmp; // recall, #define errno *_errno()
        }
        return pvBlk;
}
extern "C" static void * __cdecl _nh_malloc_dbg_impl (
        size_t nSize,
        int nhFlag,
        int nBlockUse,
        const char * szFileName,
        int nLine,
        int * errno_tmp
        )
{
        void * pvBlk;

        for (;;)
        {
            /* do the allocation
             */
            pvBlk = _heap_alloc_dbg_impl(nSize, nBlockUse, szFileName, nLine, errno_tmp);

            if (pvBlk)
            {
                return pvBlk;
            }
            if (nhFlag == 0)
            {
                if (errno_tmp)
                {
                    *errno_tmp = ENOMEM;
                }
                return pvBlk;
            }

            /* call installed new handler */
            if (!_callnewh(nSize))
            {
                if (errno_tmp)
                {
                    *errno_tmp = ENOMEM;
                }
                return NULL;
            }

            /* new handler was successful -- try to allocate again */
        }
}
/***
*void * _heap_alloc_dbg_impl() - does actual allocation
*
*Purpose:
*       Does heap allocation.
*
*       Allocates any type of supported memory block.
*
*Entry:
*       size_t          nSize       - size of block requested
*       int             nBlockUse   - block type
*       char *          szFileName  - file name
*       int             nLine       - line number
*       int  *          errno_tmp   - pointer of the temporary errno
*
*Exit:
*       Success:  Pointer to (user portion of) memory block
*       Failure:  NULL
*
*Exceptions:
*
*******************************************************************************/

extern "C" static void * __cdecl _heap_alloc_dbg_impl(
        size_t nSize,
        int nBlockUse,
        const char * szFileName,
        int nLine,
        int * errno_tmp
        )
{
        long lRequest;
        size_t blockSize;
        int fIgnore = FALSE;
        _CrtMemBlockHeader * pHead;
        void *retval=NULL;

        /* lock the heap
         */
        _mlock(_HEAP_LOCK);//这里有必要么？因为HeapAlloc本身就是互斥有序的
        __try {
            /* verify heap before allocation */
            if (check_frequency > 0)
                if (check_counter == (check_frequency - 1))
                {
                    _ASSERTE(_CrtCheckMemory());
                    check_counter = 0;
                }
                else
                    check_counter++;

            lRequest = _lRequestCurr;//调用次函数次数，全局的

            /* break into debugger at specific memory allocation */
            if (_crtBreakAlloc != -1L && lRequest == _crtBreakAlloc)
                _CrtDbgBreak();

            /* forced failure */
			//_pfnAllocHook=_CrtDefaultAllocHook;默认Alloc钩子
            if ((_pfnAllocHook) && !(*_pfnAllocHook)
(_HOOK_ALLOC, NULL, nSize, nBlockUse, lRequest, (const unsigned char *)szFileName, nLine))
            {
                if (szFileName)
                    _RPT2(_CRT_WARN, "Client hook allocation failure at file %hs line %d.\n",
                        szFileName, nLine);
                else
                    _RPT0(_CRT_WARN, "Client hook allocation failure.\n");
            }
            else
            {
                /* cannot ignore CRT allocations */
                if (_BLOCK_TYPE(nBlockUse) != _CRT_BLOCK &&
                    !(_crtDbgFlag & _CRTDBG_ALLOC_MEM_DF))
                    fIgnore = TRUE;

                /* Diagnostic memory allocation from this point on */

                if (nSize > (size_t)(_HEAP_MAXREQ - nNoMansLandSize - sizeof(_CrtMemBlockHeader)))
                {
                    _RPT1(_CRT_ERROR, "Invalid allocation size: %Iu bytes.\n", nSize);
                    if (errno_tmp)
                    {
                        *errno_tmp = ENOMEM;
                    }
                }
                else
                {
                    if (!_BLOCK_TYPE_IS_VALID(nBlockUse))
                    {
                        _RPT0(_CRT_ERROR, "Error: memory allocation: bad memory block type.\n");
                    }

                    blockSize = sizeof(_CrtMemBlockHeader) + nSize + nNoMansLandSize;

                    RTCCALLBACK(_RTC_FuncCheckSet_hook,(0));
                    pHead = (_CrtMemBlockHeader *)_heap_alloc_base(blockSize);

                    if (pHead == NULL)
                    {
                        if (errno_tmp)
                        {
                            *errno_tmp = ENOMEM;
                        }
                        RTCCALLBACK(_RTC_FuncCheckSet_hook,(1));
                    }
                    else
                    {

                        /* commit allocation */
                        ++_lRequestCurr;

                        if (fIgnore)//如果fIgnore，不记录信息，不放入链表
                        {
                            pHead->pBlockHeaderNext = NULL;
                            pHead->pBlockHeaderPrev = NULL;
                            pHead->szFileName = NULL;
                            pHead->nLine = IGNORE_LINE;
                            pHead->nDataSize = nSize;
                            pHead->nBlockUse = _IGNORE_BLOCK;
                            pHead->lRequest = IGNORE_REQ;
                        }
                        else {//否则，记录信息，放入链表
                            /* keep track of total amount of memory allocated */
                            if (SIZE_MAX - _lTotalAlloc > nSize)
                            {
                                _lTotalAlloc += nSize;//_lTotalAlloc与_lCurAlloc区别是啥？
                            }
                            else
                            {
                                _lTotalAlloc = SIZE_MAX;
                            }
                            _lCurAlloc += nSize;

                            if (_lCurAlloc > _lMaxAlloc)
                            _lMaxAlloc = _lCurAlloc;
//插入链表头
                            if (_pFirstBlock)
                                _pFirstBlock->pBlockHeaderPrev = pHead;                            else
                                _pLastBlock = pHead;

                            pHead->pBlockHeaderNext = _pFirstBlock;
                            pHead->pBlockHeaderPrev = NULL;
                            pHead->szFileName = (char *)szFileName;
                            pHead->nLine = nLine;
                            pHead->nDataSize = nSize;
                            pHead->nBlockUse = nBlockUse;
                            pHead->lRequest = lRequest;

                            /* link blocks together */
                            _pFirstBlock = pHead;
                        }

                        /* fill in gap before and after real block */
                        memset((void *)pHead->gap, _bNoMansLandFill, nNoMansLandSize);//0xFD
                        memset((void *)(pbData(pHead) + nSize), _bNoMansLandFill, nNoMansLandSize);

                        /* fill data with silly value (but non-zero) */数据初始化为0xCD
                        memset((void *)pbData(pHead), _bCleanLandFill, nSize);

                        RTCCALLBACK(_RTC_FuncCheckSet_hook,(1));
 					  //返回我们可以使用的内存地址
                        retval=(void *)pbData(pHead);
                    }
                }
            }

        }
        __finally {
            /* unlock the heap
             */
            _munlock(_HEAP_LOCK);
        }

        return retval;
}
typedef struct _CrtMemBlockHeader
{
        struct _CrtMemBlockHeader * pBlockHeaderNext;
        struct _CrtMemBlockHeader * pBlockHeaderPrev;
        char *                      szFileName;//调用此函数的文件名称
        int                         nLine;//调用此函数行号
#ifdef _WIN64
        /* These items are reversed on Win64 to eliminate gaps in the struct
         * and ensure that sizeof(struct)%16 == 0, so 16-byte alignment is
         * maintained in the debug heap.
         */
        int                         nBlockUse;
        size_t                      nDataSize;
#else  /* _WIN64 */
        size_t                      nDataSize;//请求分配的大小
        int                         nBlockUse;//用途，比如_NORMAL_BLOCK
#endif  /* _WIN64 */
        long                        lRequest;//	请求号(第多少次调用次函数）
        unsigned char               gap[nNoMansLandSize];
        /* followed by:
         *  unsigned char           data[nDataSize];
         *  unsigned char           anotherGap[nNoMansLandSize];
         */
} _CrtMemBlockHeader;

上面的这个结构就是为了把分配的内存挂到链表中去。

static _CrtMemBlockHeader * _pFirstBlock;
static _CrtMemBlockHeader * _pLastBlock;

遍历CRT堆

下面这段代码可以遍历一个程序中CRT分配的内存：

#define _CRTBLD
#include "D:\SoftWare\vs2010\VC\crt\src\dbgint.h"
int _tmain(int argc, _TCHAR* argv[])
{
	int* p = new int(11);

	_CrtMemBlockHeader* pHead = (_CrtMemBlockHeader*)((char*)p-sizeof(_CrtMemBlockHeader));
	while(pHead!=NULL)
	{
		static size_t index = 0;
		printf("%d:%s:%d\n",index++,pHead->szFileName,pHead->nLine);
		pHead = pHead->pBlockHeaderNext;
	}
	return 0;
}

 

李小乾
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 源码 之 标准库new ， operator new ， placement new ， array new
玉界尺的博客
06-21 3025
在c++中管理内存的一些手段与细节 那么这篇博客的内容主要是在学习了jjhou老师的内存管理后我自己总结的一些知识点，关于侯捷老师的内存管理的内容可以自己搜索那么直接进入正题了 1.new和operator new 依照bjarne的c++ programming language的11.2.3章节所说，new ，delete，operator new，operator delete...
visual studio CRT主函数源代码
04-11 1499
/*** *crtexe.c - Initialization for console EXE using CRT DLL * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       This is the actual startup routine for apps
c++ 源码 之 operator new 续
玉界尺的博客
06-21 550
正如我之前在 谈到new所说的我们可以重载 operator new这个函数 并且我们希望通过代码来验证talk is cheap 实验一 new expression 会调用构造函数 实验二 从载operator new 函数可以改变new的过程 c++ 真是一门帅气的语言 ，这样我们可以自己接管new的过程 ，并且只有当类型是我们希望的类型才会重载。是不是很像变魔术...
VS2010 CRT 全局锁
LiQian06336的博客
08-03 398
/* * Lock Table * This table contains a pointer to the critical section management structure * for each lock. * * Locks marked lkPrealloc have their critical sections statically allocated * ...
CRT源码-字符串处理
weixin_34367845的博客
05-07 349
2019独角兽企业重金招聘Python工程师标准>>> ...
shell脚本报错："[: =: unary operator expected"解决办法
09-15
在使用Shell脚本编程时，有时我们可能会遇到一个常见的错误提示：“[: =: unary operator expected”。这个错误通常出现在我们尝试进行条件判断时，尤其是当我们在`if`语句中使用`[ ... ]`或者`[[ ... ]]`进行比较...
java-operator:Java Operator SDK
03-12
Java Operator SDK概述该项目是的组成部分， 是一个开放源代码工具包，用于以有效，自动化和可扩展的方式管理称为Kubernetes的本机应用程序。 在了解更多。 可以轻松地在Kubernetes上管理复杂的有状态应用程序。 ...
访问管理器：Kubernetes-Operator简化RBAC配置
02-07
Access-Manager是Kubernetes-Operator，使用来简化集群中的复杂配置并在名称空间之间传播秘密。 动机 在基于名称空间的基础上管理许多不同的RBAC-Roles时，出现了这个想法。 随着时间的推移，这变得越来越复杂，...
群集监视：基于Prometheus Operator的群集的群集监视堆栈
02-04
【标题】：“群集监视：基于Prometheus Operator的群集的群集监视堆栈” 【描述】：在现代云计算环境中，Kubernetes已经成为容器编排的事实标准。为了确保系统的高可用性和稳定性，对集群进行实时、全面的监控至关...
错误：unexpected operator.docx
11-01
Shell 编程之 unexpected operator 错误解析 在 Shell 编程中，遇到「unexpected operator」错误时，不少开发者会感到困惑。今天，我们将深入探讨这类错误的成因和解决方法。 错误的成因 「unexpected operator」...
全面解析C++中的new,operator new与placement new
09-05
以下是C++中的new,operator new与placement new进行了详细的说明介绍，需要的朋友可以过来参考下
mcrt - 简单的CRT实现原型代码
06-04
自己用C++实现的一个简单的CRT源代码.及其开发环境.
创自CRT_310读卡器测试Demo源码
09-28
创自CRT_310读卡器Demo源码 包含大部分主要的操作，如：进卡、退卡、读磁条、IC卡读卡、APDU发送等等
crt VisualC++
03-27
crt是用 Visual C++ 语言开发的
常用CRT字符串函数源码
Keep It Simple, Stupid
08-08 1037
////////////////////memcpy///////////////////////// void * __cdecl memcpy ( void * dst, const void * src, size_t count ) { void * ret = dst; while (cou
[转]C Runtime Library 的来历, API, STL, MFC, ATL关系
MoonAndWind的专栏
07-03 1390
 刚接触Windows开发时，为了快速入门查了不少资料，没想到看的越多，脑袋越糊涂。因为写同一种功能的程序，找到的例程风格截然不同。拿C程序来说，有些API的名称都很长，都是没见过的变量类型而且全大写；有些跟熟悉的Linux环境C开发差不多，标准短小的C函数名。再比如某些C++程序，用的标准类也会有不同。后来专门花了点功夫，才了解Windows平台下的开发有多个不同的体系：标准C，Windows
Operator new函数
xudacheng06的专栏
09-02 1115
operator new void* operator new (std::size_t size) throw (std::bad_alloc); void* operator new (std::size_t size, const std::nothrow_t& no
operator new的三种形式
qq_55964665的博客
05-11 342
三种形式： throwing (1) void* operator new (std::size_t size) throw (std::bad_alloc); nothrow (2) void* operator new (std::size_t size, const std::nothrow_t& nothrow_value) throw(); placement (3) void* operator new (std::size_t size, void* p...
C++中new的源码与行为分析
LPWSTR的博客
03-25 5223
这是我在处女面中遇到的一个问题，当时回答的不太好，因此下来研究、学习了一下。C++中operator new的行为及其与malloc的区别。当时我回答二者的区别是new在实现中会调用malloc并且由编译器安插调用构造函数的代码，并在面试官前辈的提醒下又答出malloc失败返回0，而new直接抛异常。但不清楚有没有不抛异常的new和不调用构造函数的new这一点。下面结合代码分析一下。
::operator new(sizeof(T))
最新发布
07-13
::operator new(sizeof(T)) 是 C++ 中的一个运算符，用于在堆上分配指定大小的内存空间。它返回一个指向分配的内存块的指针，可以用于在该内存块中构造对象。 这个运算符与 new 关键字不同，new 运算符在分配内存的同时还会调用对象的构造函数，而 ::operator new 只分配内存而不调用构造函数。因此，使用 ::operator new 分配内存后，需要手动调用对象的构造函数来构造对象。 下面是一个示例代码，展示了如何使用 ::operator new 分配内存并构造对象： ```cpp #include <iostream> class MyClass { public: MyClass() { std::cout << "MyClass constructor" << std::endl; } }; int main() { MyClass* obj = static_cast<MyClass*>(::operator new(sizeof(MyClass))); // 分配内存 new (obj) MyClass(); // 构造对象 // 使用 obj 指针操作对象 obj->~MyClass(); // 手动调用析构函数 ::operator delete(obj); // 释放内存 return 0; } ``` 在上述代码中，我们首先使用 ::operator new 分配了足够的内存来存储一个 MyClass 对象，然后使用 placement new 语法在这块内存上构造了一个 MyClass 对象。最后，我们手动调用了析构函数和 ::operator delete 来释放内存。 需要注意的是，使用 ::operator new 和 placement new 需要更加谨慎，因为它们直接操作内存，没有像 new 关键字那样提供了更多的语法和错误处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值