int globalVar = 1;//全局變量中在靜態(tài)區(qū)
static int staticGlobalVar = 1;//靜態(tài)區(qū)
void Test()
{
    static int staticVar = 1;//靜態(tài)區(qū)
    int localVar = 1;//棧區(qū)
    int num1[10] = { 1, 2, 3, 4 };//棧區(qū)
    char char2[] = "abcd";//棧區(qū)，*char2在棧區(qū)
    const char* pChar3 = "abcd";//指針在棧區(qū)，*pchar3在常量區(qū)
    int* ptr1 = (int*)malloc(sizeof(int) * 4);//指針在棧區(qū)，*ptr1在堆區(qū)
    int* ptr2 = (int*)calloc(4, sizeof(int));///棧區(qū)
    int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);//棧區(qū)
    free(ptr1);
    free(ptr3);
}

int main()
{
    int* p1 = new int;//在堆區(qū)申請(qǐng)一個(gè)int大小的空間，不會(huì)初始化
    int* p2 = new int(0);//申請(qǐng)并初始化為0
    delete p1;
    delete p2;
 
    int* p3 = new int[10];//在堆區(qū)申請(qǐng)一塊10個(gè)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
             // 如果申請(qǐng)內(nèi)存失敗了，這里會(huì)拋出bad_alloc 類型異常
             static const std::bad_alloc nomem;
             _RAISE(nomem);
         }
    return (p);
}

//operator delete: 該函數(shù)最終是通過(guò)free來(lái)釋放空間的
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 );//調(diào)用free()
     __FINALLY
         _munlock(_HEAP_LOCK);  /* release other threads */
     __END_TRY_FINALLY
     return; }
//free的實(shí)現(xiàn)
#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接收常性實(shí)參
{
    return a + b;
}
int main()
{
    int a = 10, b = 5;
    double m = 2.3, n = 4.9;
    Add(a, (int)m);//強(qiáng)轉(zhuǎn)，臨時(shí)變量傳參，具有常性
    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);//顯式實(shí)例化，m發(fā)生隱式類型轉(zhuǎn)換
    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);多個(gè)模板的手動(dòng)推演
    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);//調(diào)用已有實(shí)例
    Add<int>(a, m);//調(diào)用模板生成的實(shí)例
    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;