详解C++中动态内存管理和泛型编程

int globalVar = 1;//全局变量中在静态区
static int staticGlobalVar = 1;//静态区
void Test()
{
    static int staticVar = 1;//静态区
    int localVar = 1;//栈区
    int num1[10] = { 1, 2, 3, 4 };//栈区
    char char2[] = "abcd";//栈区，*char2在栈区
    const char* pChar3 = "abcd";//指针在栈区，*pchar3在常量区
    int* ptr1 = (int*)malloc(sizeof(int) * 4);//指针在栈区，*ptr1在堆区
    int* ptr2 = (int*)calloc(4, sizeof(int));///栈区
    int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);//栈区
    free(ptr1);
    free(ptr3);
}

int main()
{
    int* p1 = new int;//在堆区申请一个int大小的空间，不会初始化
    int* p2 = new int(0);//申请并初始化为0
    delete p1;
    delete p2;
 
    int* p3 = new int[10];//在堆区申请一块10个int大小的空间，未初始化
    int* p4 = new int[10]{ 1,2,3,4 };//初始化为{1,2,3,4,0,0,0,0,0,0}
    delete[] p3;
    delete[] p4;
    return 0;
}

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
             // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
             static const std::bad_alloc nomem;
             _RAISE(nomem);
         }
    return (p);
}

//operator delete: 该函数最终是通过free来释放空间的
void operator delete(void *pUserData) {
     _CrtMemBlockHeader * pHead;
     RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
     if (pUserData == NULL)
         return;
     _mlock(_HEAP_LOCK);  /* block other threads */
     __TRY
         /* get a pointer to memory block header */
         pHead = pHdr(pUserData);
          /* verify block type */
         _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
         _free_dbg( pUserData, pHead->nBlockUse );//调用free()
     __FINALLY
         _munlock(_HEAP_LOCK);  /* release other threads */
     __END_TRY_FINALLY
     return; }
//free的实现
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

int main()
{
    Date d1;
    new(&d1)Date;//new (指针)类名
    Date* p = new Date[4]{ {2022,10,15},{2023,11,8} };
    new(p)Date[4];//new (指针) type(初始化列表)
    delete[] p;
    return 0;
}

template<typename T>
void Swap(T& a, T& b)
{
    T tmp = a;
    a = b;
    b = tmp;
}
int main()
{
    int a = 10, b = 5;
    double m = 2.3, n = 4.9;
    Swap(a, b);
    Swap(m, n);
    return 0;
}

template<typename T>
T Add(const T& a,const T& b)//const接收常性实参
{
    return a + b;
}
int main()
{
    int a = 10, b = 5;
    double m = 2.3, n = 4.9;
    Add(a, (int)m);//强转，临时变量传参，具有常性
    return 0;
}

template<typename T>
T Add(const T& a, const T& b)//需要使用const接收
{
    return a + b;
}
int main()
{
    int a = 10, b = 5;
    double m = 2.3, n = 4.9;
    Add<int>(a, m);//显式实例化，m发生隐式类型转换
    return 0;
}

template<typename T1,class T2>//可以写typename也可以写class
T1 Add(const T1& a, const T2& b)
{
    return a + b;
}
int main()
{
    int a = 10, b = 5;
    double m = 2.3, n = 4.9;
    Add(a, m);//Add<int,double>(a,m);多个模板的手动推演
    return 0;
}

template<typename T>//可以写typename也可以写class
T Add(const T& a, const T& b)
{
    return a + b;
}
int Add(const int& a, const int& b)
{
    return a + b;
}
int main()
{
    int a = 10, b = 5;
    double m = 2.3, n = 4.9;
    Add(a, m);//调用已有实例
    Add<int>(a, m);//调用模板生成的实例
    return 0;
}

int main()
{
    Stack<double> st1; // double
    st1.Push(1.1);
    Stack<int> st2; // int
    st2.Push(1);
    return 0;
}

// Vector是类模板，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;