[Boolan] C++第五週 重載const，new，delete

動態綁定

#include <iostream>
#include <string>

class Animal {
public:
    virtual ~Animal() { }
    virtual void say() = 0;
    virtual void Print() = 0;
};

class Cat : public Animal {
public:
    Cat(const std::string& str): name(str) { }
    virtual void say() {
        std::cout << name << " miaomiao~~ " << std::endl;
    }
    virtual void Print() {
        std::cout << " Cat Print" << std::endl;
    }
private:
    std::string name;
};

class Dog : public Animal {
public:
    Dog(const std::string& str) : name(str) { }
    virtual void say() {
        std::cout << name << " wangwang~~ " << std::endl;
    }
    virtual void Print() {
        std::cout << " Dog Print" << std::endl;
    }
private:
    std::string name;
};

void test21() {
    Cat cat("cat");
    Dog dog("dog");
    Animal* pcat = &cat;
    Animal* pdog = &dog;

    std::cout << "L01: ";
    pcat->say();
    std::cout << "L02: ";
    pdog->say();
    std::cout << "L03: ";
    cat.say();
    std::cout << "L04: ";
    dog.say();

    /* 互換了兩個虛函數表的指針vtpr */
    void* tmp = ((void**)pcat)[0];      
    ((void**)pcat)[0] = ((void**)pdog)[0];
    ((void**)pdog)[0] = tmp;

    std::cout << "L05: ";
    pcat->say();
    pcat->Print();
    std::cout << "L06: ";
    pdog->say();
    pdog->Print();
    std::cout << "L07: ";
    cat.say();          //靜態綁定，在程序編譯完就以確定
    std::cout << "L08: ";   //靜態綁定，在程序編譯完就以確定
    dog.say();
}

int main() {
    test21();

    return 0;
}

const 重載

const修飾類成員函數，該成員函數裏面不可能修改成員變量
其中const也算函數簽名的一部分， 只用於在類的成員函數
const的重載使用條件：如果一個類聲明中有const重載的函數，const對象使用const修飾的成員函數，非const對象使用沒有const修飾的成員函數

#include <iostream>

using namespace std;

class Foo
{
public:
    void Print() const{
        cout << "Foo::Print const" << endl;
    }
    void Print(){
        cout << "Foo::Print" << endl;
    }
};

int main(int argc, char *argv[])
{
    const Foo fConst;
    fConst.Print();

    Foo f;
    f.Print();

    return 0;
}

重載new delete

new ---->   operator new   分配空間
            調用相應的構造函數
delete  ---- >  調用析構函數
            operator delete

#include <iostream>
#include <string>

using namespace std;

class Foo
{
private:
    int     _id;
    long    _data;
    string  _str;

public:
    Foo():_id(0)
    {
        cout << "default ctor. this=" << this << " id="<<_id << endl;
    }
    Foo(int i): _id(i)
    {
        cout << "ctor.this=" << this << " id=" << _id << endl;
    }

    ~Foo()
    {
        cout << "dtor.this=" <<this << " id=" << _id <<endl;
    }

    static void *operator new(size_t size);
    static void operator delete(void* pdead, size_t size);

    static void *operator new[](size_t size);
    static void operator delete[] (void*pdead, size_t size);

};

void * Foo::operator new(size_t size)
{
    cout << " Foo::operator new " << endl;
    Foo *p = (Foo*)malloc(size);
    return p;
}

void Foo::operator delete(void* pdead, size_t size)
{
    cout << " Foo::operator delete " << endl;
    free(pdead);
}

void * Foo::operator new[](size_t size)
{
    Foo* p = (Foo*)malloc(size);
    return p;
}

void Foo::operator delete[](void*pdead, size_t size)
{
    free(pdead);
}

int main(int argc, char *argv[])
{
    Foo *pf = new Foo;
    delete pf;

    cout << "-----------------" <<endl;

    //強制調用全局的new/delete

    Foo *p = ::new Foo;     
    ::delete p;


    return 0;
}

重載new() delete()

我們可以重載類的成員函數operator new(), 寫出多個版本，前提是每個版本的聲明必須有獨特的參數列，其中第一個參數必須是size_t, 其餘參數指定的placement arguments爲初值

    Foo* pf = new (300, 'c')Foo;

我們也可以重載類的成員函數operator delete()，寫出多個版本，但是他們絕不會被delete調用。只有當new所調用的析構函數拋出exception，纔會調用這些重載版的operator delete(). 它只可能這樣被調用，主要用來歸還未能完全創建成功的object所佔的memory.
並且重載版的delete是被系統自動調用的

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

using namespace std;

namespace test1{
    class Foo
    {
    public:
        void Print() const{
            cout << "Foo::Print const" << endl;
        }
        void Print(){
            cout << "Foo::Print" << endl;
        }
    };
};

namespace test2 {
    class Bad{};

    class Foo{
    public:
        Foo() { cout << "Foo::Foo()" <<endl; }
        Foo(int)    {cout << "Foo::Foo(int)" << endl; throw "拋出異常";}

        //(1)
        static void* operator new(size_t size) { 
            return malloc(size); 
        }

        static void operator delete(void* pdead, size_t size)   {
            cout << "void operator delete(void* pdead, size_t size)" <<endl;
            free(pdead);
        }

        //(2)
        static void* operator new(size_t size, void *)  {
            return malloc(size); 
        } 

        static void operator delete(void *, void *) {
            cout << "operator delete(void *, void *)" << endl;
        }

        //(3)
        static void* operator new(size_t size, long extra) {
            return malloc(size + extra);
        }

        static void operator delete(void *pHead, long) {
            cout << "operator delete(void *, long)" << endl;
            //free(pHead);
        }

        //(4)
        static void* operator new(size_t size, long extra, char init) {
            return malloc(size + extra);
        }

        static void operator delete(void *pHead, long, char) {
            cout << "operator delete(void *, long, char)" << endl;
            free(pHead);
        }
    };
};




int main(int argc, char *argv[])
{
    test2::Foo start;
    test2::Foo *p1; 
    test2::Foo *p2; 
    test2::Foo *p3 ;    
    test2::Foo *p4;     
    test2::Foo *p5 ;


    try
    {
        p1 = new test2::Foo;
        p2 = new (&start) test2::Foo;
        p3 = new (100)test2::Foo;
        p4 = new (100, 'a')test2::Foo;
        p5 = new (100)test2::Foo(1);
    }
    catch (const char* msg)
    {
        cout << msg<<endl;
    }

    return 0;
}

////////////////////////////////  環境VC6.0
Foo::Foo()
Foo::Foo()
Foo::Foo()
Foo::Foo()
Foo::Foo()
Foo::Foo(int)
operator delete(void *, long)
拋出異常
Press any key to continue

引用場景:string中使用重載operator new()的方式，給一塊內存添加引用計數，可節省內存空間