关于 C++ 的 new、delete 与 C 的 malloc、free 的区别

因为平台实时库部分的封装有点小恶心,如果取数据,用户必须传入一个有效的buf的初始地址和长度,接口内部的实现会在长度不够的情况下自动realloc这块buf,所以用户的缓存必须是malloc出来的。部门的个别小伙儿喜欢用了new来分配内存,当然了buf的长度足够大,是不会出问题的,如果一开始分配的比较小,问题就来了。纠结于因为这个问题,老是会被问及C/C++内存管理的差异,特写了个小程序以验证(写的不是很严谨,仅为主题,分别在redhat 5.6 x86_64 + gcc-4.9.2,windows 7
x64 + gcc-4.9.2 编译运行通过):

代码:

#include <iostream>
#include <typeinfo>
#include <stdlib.h>
#include <stdio.h>

void t_cpu()
{
#define print_type(t) std::cout << "Size of " << #t <<  ": " << sizeof(t) << std::endl
    print_type(char);
    print_type(unsigned char);
    print_type(short);
    print_type(unsigned short);
    print_type(int);
    print_type(unsigned int);
    print_type(size_t);
    print_type(long);
    print_type(unsigned long);
    print_type(long long);
    print_type(unsigned long long);
    print_type(float);
    print_type(double);
    print_type(long double);
    print_type(void*);

}

void t_new(size_t sl)
{
    class __T {
    public:
        int _1;
        int _2;

        __T(){
            _1 = 1;
            _2 = 2;
        }
        ~__T(){
            printf("~");
        }

        void test()
        {
            _1 += _2;
        }
    };

    __T *pchar = new __T[sl];
    size_t  *psize  = (size_t*)(((char*)pchar)-sizeof(size_t));
    printf("\nTest new and delete \nsize: %ld pchar: %p psize: %p *psize: %ld \n", sl, pchar, psize, *psize);
    delete []pchar;
    printf("\n");
}

void t_malloc(size_t sl)
{
    class __T {
    public:
        int _1;
        int _2;

        __T(){
            _1 = 1;
            _2 = 2;
        }
        ~__T(){
            printf("~");
        }

        void test()
        {
            _1 += _2;
        }
    };

    printf("\nTest malloc and free \nsize of class __T: %ld  \n", sizeof(class __T));
    __T *pchar = (__T *)malloc(sl * sizeof(class __T));
    size_t  *psize  = (size_t*)(((char*)pchar)-sizeof(size_t));
    printf("size: %ld pchar: %p psize: %p *psize: %ld \n", sl, pchar, psize, *psize);
    free(pchar);
}

void t_new_free(size_t sl)
{
    class __T {
    public:
        int _1;
        int _2;

        __T(){
            _1 = 1;
            _2 = 2;
        }
        ~__T(){
            printf("~");
        }

        void test()
        {
            _1 += _2;
        }
    };

    __T *pchar = new __T[sl];
    size_t  *psize  = (size_t*)(((char*)pchar)-sizeof(size_t));
    printf("\nTest new and free \nsize: %ld pchar: %p psize: %p *psize: %ld \n", sl, pchar, psize, *psize);
    //delete []pchar;
    for (__T *t = pchar; t < pchar + sl; ++t) {
        t->~__T();
    }

    free(psize);
    printf("\n");
}

void t_malloc_delete(size_t sl)
{
    class __T {
    public:
        int _1;
        int _2;

        __T(){
            _1 = 1;
            _2 = 2;
        }
        ~__T(){
            printf("~");
        }

        void init()
        {
            _1 = 7;
            _2 = 8;
        }

        void test()
        {
            _1 += _2;
        }
    };

    printf("\nTest malloc and delete \nsize of class __T: %ld  \n", sizeof(class __T));
    size_t *psize = (size_t *)malloc(sl * sizeof(class __T) + sizeof(size_t));
    __T  *pchar  = (__T*)(((char*)psize)+sizeof(size_t));
    *psize = sl;
    //for (__T *t = pchar; t < pchar + sl; ++t) {
    //    t->init();
    //}
    printf("size: %ld pchar: %p psize: %p *psize: %ld \n", sl, pchar, psize, *psize);
    delete [] pchar;
    printf("\n");
}

int main()
{
    t_cpu();
    t_new(48);
    t_malloc(32);
    t_new_free(16);
    t_malloc_delete(8);
    return 0;
}

输出(redhat):

Size of char: 1
Size of unsigned char: 1
Size of short: 2
Size of unsigned short: 2
Size of int: 4
Size of unsigned int: 4
Size of size_t: 8
Size of long: 8
Size of unsigned long: 8
Size of long long: 8
Size of unsigned long long: 8
Size of float: 4
Size of double: 8
Size of long double: 16
Size of void*: 8

Test new and delete
size: 48 pchar: 0x2442018 psize: 0x2442010 *psize: 48
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Test malloc and free
size of class __T: 8
size: 32 pchar: 0x2442010 psize: 0x2442008 *psize: 273 

Test new and free
size: 16 pchar: 0x2442018 psize: 0x2442010 *psize: 16
~~~~~~~~~~~~~~~~

Test malloc and delete
size of class __T: 8
size: 8 pchar: 0x2442018 psize: 0x2442010 *psize: 8
~~~~~~~~

输出(Windows):

Size of char: 1
Size of unsigned char: 1
Size of short: 2
Size of unsigned short: 2
Size of int: 4
Size of unsigned int: 4
Size of size_t: 4
Size of long: 4
Size of unsigned long: 4
Size of long long: 8
Size of unsigned long long: 8
Size of float: 4
Size of double: 8
Size of long double: 12
Size of void*: 4

Test new and delete
size: 48 pchar: 00991b54 psize: 00991b50 *psize: 48
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Test malloc and free
size of class __T: 8
size: 32 pchar: 00991b50 psize: 00991b4c *psize: 134253675

Test new and free
size: 16 pchar: 00991b54 psize: 00991b50 *psize: 16
~~~~~~~~~~~~~~~~

Test malloc and delete
size of class __T: 8
size: 8 pchar: 00991b54 psize: 00991b50 *psize: 8
~~~~~~~~
时间: 2024-10-29 19:11:29

关于 C++ 的 new、delete 与 C 的 malloc、free 的区别的相关文章

MySQL DELETE语句和TRUNCATE TABLE语句的区别

MySQL DELETE语句和TRUNCATE TABLE语句的区别 2010-10-08 16:05 佚名 互联网 字号:T | T 在MySQL数据库中,DELETE语句和TRUNCATE TABLE语句都可以用来删除数据,但是这两种语句还是有着其区别的,下文就为您介绍这二者的差别所在. AD:干货来了,不要等!WOT2015 北京站演讲PPT开放下载! MySQL DELETE语句和TRUNCATE TABLE语句功能相似,但是二者究竟有何区别呢?下文就将为您分析MySQL DELETE语

new/delete与malloc/free的区别

参考: https://blog.csdn.net/u013485792/article/details/51329541 https://www.cnblogs.com/lyl-312/p/5528892.html http://www.cnblogs.com/QG-whz/p/5140930.html https://blog.csdn.net/gukesdo/article/details/7506155 本文在写作中参考了上述文章,特此感谢! [导语] 之前对new和delete,mal

new/delete 与 malloc/free的区别

一.概述 在C++中,申请动态内存与释放动态内存用new/delete 与 malloc/free都可以,而且他们的存储方式相同,new/malloc申请的动态内存位于堆中,无法被操作系统自动回收,需要对应的delete也free释放空间. malloc/free是C/C++语言的标准库函数,在C语言中需要头文件#include<stdlib.h>的支持.而new/delete是C++的运算符.对于类对象而言,malloc/free无法满足动态对象的要求,对象要求在创建的同时自动执行构造函数,

new delete和malloc free的区别

部分内容摘自:http://www.52rd.com/bbs/Archive_Thread.asp?SID=209143&TID=3&WebShieldDRSessionVerify=QWlrR3KW8IElo27YO6zv 一.他们分别是什么 new和delete是c++中的操作符,malloc和free是c/c++的标准库函数. 在使用完分配的内存时,要及时用delete和free进行内存释放,避免内存泄漏. 二.他们之间的区别 1.malloc的原型为:void * malloc(s

new/delete 和 malloc/free 的区别

1.malloc/free是C/C++语言的标准库函数,new/delete是C++的运算符.它们都可用于申请动态内存和释放内存.但是new能够自动分配空间大小,而malloc需要计算字节数. 2.对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求.对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数.由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free. 因此C++语言

C++中,new/delete和malloc/free的区别

1.new/delete是C++的操作符,而malloc/free是C中的函数. 2.new做两件事,一是分配内存,二是调用类的构造函数:同样,delete会调用类的析构函数和释放内存.而malloc和free只是分配和释放内存. 3.new建立的是一个对象,而malloc分配的是一块内存:new建立的对象可以用成员函数访问,不要直接访问它的地址空间:malloc分配的是一块内存区域,用指针访问,可以在里面移动指针:new出来的指针是带有类型信息的,而malloc返回的是void指针. 4.ne

new/delete 和malloc/free 的区别一般汇总

一.基本概念 malloc/free: 1.函数原型及说明: void *malloc(long NumBytes):该函数分配了NumBytes个字节,并返回了指向这块内存的指针.如果分配失败,则返回一个空指针(NULL). void free(void *FirstByte): 该函数是将之前用malloc分配的空间还给程序或者是操作系统,也就是释放了这块内存,让它重新得到自由. 2.内存操作: malloc函数的参数是接受需要分配的内存字节数,如果内存能够满足请求量,那么将会返回:指向被分

new/delete、malloc/free 的区别

相同点 1.都可以动态的申请或释放内存 2.存储方式相同,动态申请的内存都存放在堆中,无法自动释放,要调用对应的delete和free 区别 1.new能自行的计算需要分配的空间,malloc需要手动计算字节数 int *p1 = new int[10]; int *p2 = (int*)malloc(10*sizeof(int)); 2.new和delete直接带具体类型的指针,malloc和free返回void类型的指针 void *p2 = malloc(10*sizeof(int));

请说明SQLServer中delete from tablea &amp; truncate table tablea的区别

解答:两者都可以用来删除表中所有的记录.区别在于:truncate是DDL操作,它移动HWK,使HWK值为0,不需要 rollback segment .而Delete是DML操作需要rollback segment 且花费较长时间. 原文地址:https://www.cnblogs.com/borter/p/9547538.html