[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()的方式，给一块内存添加引用计数，可节省内存空间