目的：使用七牛云获得对象存储空间
 
第一步：注册账号，然后去实名认证，只有实名认证才有免费的10G
 
第二步：创建  对象存储 
 
 
 
 
 
 
 
 
 

 
目录
 
C语言动态内存开辟的管理方式
C++语言动态内存开辟的管理方式
`malloc/free`和`new/delete`的异同点
 

 
C语言动态内存开辟的管理方式
 
：malloc/calloc/realloc
 malloc/calloc/realloc开辟空间的相同点：
 
 
 
都是C语言的库函数，在使用时都必须包含相应的头文件
都是从堆上申请空间，使用完成时必须要通过free来进行释放，否则，内存泄漏
申请空间成功后，返回空间的首地址，申请失败返回NULL，因此在使用时必须判空
返回值类型为void*，在使用时要进行强制类型转化
 
 
void Test () 
{ 
     //malloc
     int* p1 = (int*) malloc(sizeof(int)); 
     free(p1);
     //calloc
     int* p2 = (int*)calloc(4, sizeof (int)); 
     // realloc
     int* p3 = (int*)realloc(p2, sizeof(int)*10);  
     free(p3 ); 
}
 
malloc/calloc/realloc开辟空间的不同点：
 malloc:
 
#include<stdlib.h>/#include<malloc.h>
void *malloc( size_t size );
 
malloc只是开空间，参数是要申请空间的字节大小
 
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
void main( void )
{
   int *buffer;
   size_t size;
   buffer = (int *)malloc( 1000 * sizeof( int ) )
   if( buffer == NULL )
      printf( "Can't allocate memory\n" );	
   if( buffer != NULL )
      printf( "Allocated 1000 int integers\n" );
   free( buffer );
}
 
calloc:
 
#include <malloc.h>/#include <stdlib.h>
void *calloc( size_t num, size_t size );
 
1.开辟空间后空间会被初始化为0.
 2.参数有两个，一个是申请元素的个数num，另一个表示单个元素类型的大小size
 
#include <stdio.h>
#include <malloc.h>
void main( void )
{
   long *buffer;
   buffer = (long *)calloc( 40, sizeof( long ) );
   if( buffer != NULL )
      printf( "Allocated 40 long integers\n" );
   else
      printf( "Can't allocate memory\n" );
   free( buffer );
}
 
realloc:
 
#include <malloc.h>/#include <stdlib.h>
void *realloc( void *memblock, size_t size );
 
realloc是进行空间大小调整的操作。（新的大小要大于原来的大小，否则会导致数据丢失）
 功能：先判断当前的指针是否有足够的连续空间，如果有，扩大memblock指向的地址，并且将memblock返回，如果空间不够，先按照size指定的大小分配空间，将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来memblock所指内存区域（注：原来指针是自动释放，不需要使用free），同时返回新分配的内存区域的首地址。即重新分配存储器块的地址。
 
 
 
注：
 1.如果memblock为NULL，则realloc()和malloc()类似。分配一个size的内存块，返回一个指向该内存块的指针。
 2.如果size大小为0，那么释放memblock指向的内存，并返回NULL。
 3.如果没有足够可用的内存用来完成重新分配（扩大原来的内存块或者分配新的内存块），则返回NULL。而原来的内存块保持不变。
 
 
int main () 
{ 
     int* p2 = (int*)calloc(4, sizeof (int)); 
     //通过realloc来扩大p2的空间，并把新的地址赋值给p3
     int* p3 = (int*)realloc(p2, sizeof(int)*10);  
     free(p3 ); 
     return 0；
}
 
总结
 
 
 
realloc失败的时候，返回NULL
realloc失败的时候，原来的内存不改变，不会释放也不会移动
假如原来的内存后面还有足够多剩余内存的话，realloc的内存=原来的内存+剩余内存,realloc还是返回原来内存的地址; 假如原来的内存后面没有足够多剩余内存的话，realloc将申请新的内存，然后把原来的内存数据拷贝到新内存里，原来的内存将被free掉,realloc返回新内存的地址
如果size为0，效果等同于free()。（对指针本身进行释放）
传递给realloc的指针必须是先前通过malloc(), calloc(), 或realloc()分配的
 6.传递给realloc的指针可以为空，等同于malloc。
 
 
C++语言动态内存开辟的管理方式
 
new和delete
 注：C++兼容C语言，所以C语言内存管理方式在C++中可以继续使用，但是有了C++机制的关键字，优先使用C++的关键字。
 申请内置类型空间：
 
void Test() 
{ 
      // 动态申请一个int类型的空间 
      int* ptr4 = new int; 
      // 动态申请一个int类型的空间并初始化为10 
      int* ptr5 = new int(10);
      delete ptr4; 
      delete ptr5; 
      //管理对象组
      // 动态申请3个int类型的空间 
      int* ptr6 = new int[3]; 
      delete[] ptr6; 
}
 
class Test
{
public:
    Test()
        : _data(0)
    {
        cout<<"Test():"<<this<<endl;
    }
    ~Test()
    {
        cout<<"~Test():"<<this<<endl;
    }
private:
    int _data;
}
void Test1()
{
	//申请一个Test类型空间
    Test *p1=(Test*)malloc(sizeof(Test));
    free(p1);
    //申请10个Test类型空间
    Test *p2=(Test*)malloc(sizeof(Test)*10);
    free(p2);
}
void Test2()
{
	//申请一个Test类型的空间并初始化为10
    Test *p2=new Test(10);
    delete p2;
    //申请10个Test类型的空间
    Test *p3=new Test[10];
    delete[] p3;
}
 
在申请自定义类型的空间时，new会自动调用构造函数，delete会自动调用析构函数
 
 
 
注：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和 delete[],搭配使用，避免出错。（对于内置类型来说，new[]开辟的空间用delete来释放程序不会崩溃，因为内置类型的空间开辟和释放不会调用构造函数和析构函数）
 
 
malloc/free和new/delete的异同点
 
malloc/free和new/delete的共同点是：
 都是从堆上申请空间，并且需要用户手动释放。
 malloc/free和new/delete不同的地方是：
 
 
 
malloc和free是函数，new和delete是操作符
malloc申请的空间不会初始化，new可以初始化
malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间 后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
 

java 中new一个对象是 在堆中开辟新空间，
 声明对象是栈中 栈中保存的地址引用 为堆的地址
 new是new一个构造方法
 
 
 

#include <iostream>
using namespace std;

class A
{
private:
    int n;
public:
    A(int m):n(m)
    {
    }
    ~A(){}
};

int main()
{
    A a(1);  //栈中分配
    A b = A(1);  //栈中分配
    A* c = new A(1);  //堆中分配
　　delete c;
    return 0;
}
复制代码
第一种和第二种没什么区别，一个隐式调用，一个显式调用，两者都是在进程虚拟地址空间中的栈中分配内存，而第三种使用了new，在堆中分配了内存，而栈中内存的分配和释放是由系统管理，而堆中内存的分配和释放必须由程序员手动释放，所以这就产生一个问题是把对象放在栈中还是放在堆中的问题，这个问题又和堆和栈本身的区别有关：

这里面有几个问题：

1.堆和栈最大可分配的内存的大小

2.堆和栈的内存管理方式

3.堆和栈的分配效率

首先针对第一个问题，一般来说对于一个进程栈的大小远远小于堆的大小，在linux中，你可以使用ulimit -s (单位kb)来查看一个进程栈的最大可分配大小，一般来说不超过8M，有的甚至不超过2M，不过这个可以设置，而对于堆你会发现，针对一个进程堆的最大可分配的大小在G的数量级上，不同系统可能不一样，比如32位系统最大不超过2G，而64为系统最大不超过4G，所以当你需要一个分配的大小的内存时，请用new，即用堆。

其次针对第二个问题，栈是系统数据结构，对于进程/线程是唯一的，它的分配与释放由操作系统来维护，不需要开发者来管理。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时，这些存储单元会被自动释放。栈内存分配运算内置于处理器的指令集中，效率很高，不同的操作系统对栈都有一定的限制。 堆上的内存分配，亦称动态内存分配。程序在运行的期间用malloc申请的内存，这部分内存由程序员自己负责管理，其生存期由开发者决定：在何时分配，分配多少，并在何时用free来释放该内存。这是唯一可以由开发者参与管理的内存。使用的好坏直接决定系统的性能和稳定。

由上可知，但我们需要的内存很少，你又能确定你到底需要多少内存时，请用栈。而当你需要在运行时才知道你到底需要多少内存时，请用堆。

最后针对第三个问题，栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率 比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在 堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会 分 到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。

由上可知，能用栈则用栈。

复制代码
#include <stdio.h>
#include <stdlib.h>  
void main()
{
 int n,*p,i,j,m;
 printf("本程序可对任意个整数排序;\n");
 printf("请输入整数的总个数: ");
 scanf("%d",&n);
 p=(int *)calloc(n,sizeof(int));    //运行时决定内存分配大小
 if(p==0)   {
  printf("分配失败!\n");  
  exit(1);  
 }