标准C++之运算符重载和虚表指针

1 -> *运算符重载

//autoptr.cpp

 

 

#include<iostream>

#include<string>

using namespace std;

 

struct date{

    int year;

    int month;

    int day;

};

 

struct Person{

    string name;

    int age;

    bool gender;

    double salary;

    date birthday;

   

    Person() {cout<<"创建Person对象在"<<this<<endl;}

   

    ~Person(){cout<<"释放Person对象在"<<this<<endl;}

};

 

class autoptr{

    Person *p;

    static int cnt;

public:

    autoptr(Person *p):p(p){}

    autoptr(const autoptr& a):p(a.p){++cnt;}

 

   

    ~autoptr(){

        cout<<"cnt="<<autoptr::cnt<<endl;

        if(--cnt==0)

        delete p;

    }

 

    Person* operator->() {return p;}  //将对象模拟成指针

   

    Person& operator*() {return *p;}

};

 

int autoptr::cnt=0;

 

int main()

{

    //autoptr a(new Person());

    autoptr a=new Person();

    autoptr b=a;

    autoptr c=a;

 

    cout<<"=============================="<<endl;

 

    a->name="zhangming";

    cout<<"name:"<<(*a).name<<endl;

 

    a->birthday.year=1993;

    a->birthday.month=10;

    a->birthday.day=9;

    cout<<"birthday:"<<(*a).birthday.year<<"/"<<(*a).birthday.month

        <<"/"<<(*a).birthday.day<<endl;

   

    cout<<"==============================="<<endl;

 

    return 0;

}

 

 

2.赋值运算符=重载,实现堆栈类

//stack.cpp

 

 

#include<iostream>

#include<string>

using namespace std;

 

typedef unsigned int uint;

 

class Stack

{

public:

    Stack(uint n):mem(new string[n]),max(n),len(0){}

    Stack(const Stack &s):mem(new string[s.max]),

                  max(s.max),len(s.len){}

 

    uint max_size()const {return max;} 

    uint size()const {return len;}

 

    Stack& push(const string &s)

    {

        if(len>=max) throw 1;

        mem[len++]=s;

        return *this;

    }

   

    string pop()

    {

        if(len==0) throw 0;

        return mem[--len];

    }

 

    ~Stack(){ delete[]mem; }

 

    void print()const{

        for(int i=0;i<len;i++)

        {

            cout<<mem[i]<<" ";

        }

        cout<<endl;

    }

 

    //重载赋值运算符

    Stack& operator=(const Stack &s)

    {

        if(*this==s)  return *this;  //考虑到自己给自己赋值

 

        delete[]mem; //释放原来的空间

 

        this->mem=new string[s.max];

        this->len=s.len;

        this->max=s.max;

 

        for(int i=0;i<len;i++)

        {

            mem[i]=s.mem[i];

        }

 

        return *this;

    }

 

private:

    string* mem;   

    uint max;

    uint len;

};

 

 

int main()

{

    Stack s1(5);

    Stack s2(s1); //错误，s1与s2同时指向同一块内存,

              //致使delete重复释放,

              //可以使用拷贝构造函数解决

    Stack s3(8);

 

    s1.push("1").push("2").push("3").push("4").push("5");

    s1.print();

 

    s1.pop();

    s1.pop();

   

    s1.print();

 

    s2.push("zhangming").push("wangwu");

    s2.print();

   

    s3=s1;   //s3.operator=(s1)

    s3.print();  //1 2 3

 

    s1=s2;

    s1.print();  //zhangming wangwu

 

    s3=s3;

    s3.print();  //1 2 3

 

    return 0;

}

 

 

 

3.new delete 运算符重载

//ND.cpp

 

#include<iostream>

using namespace std;

 

const int max_size=1000;

int mem[max_size];

 

class A

{

public:

    A(){cout<<"A()"<<endl;}

   

    ~A(){cout<<"~A()"<<endl;}

 

    static void* operator new(size_t bytes)  //bytes=sizeof(A)

    {

        cout<<"new"<<endl;

 

        alloc=bytes;  //即alloc=sizeof(A)

        if(alloc>max_size) throw 0;

 

        return (mem+alloc);

    }

 

    static void operator delete(void *p)

    {

        cout<<"delete"<<endl;

        alloc=0;   

    }

 

    void init(int n){

        memset(mem,max_size,sizeof(int));

        for(int i=0;i<n;i++)

        {

            mem[i]=i;  

        }

    }

 

    void show(){

        for(int i=0;i<alloc;i++)

        {

            cout<<mem[i]<<" "; 

        }

        cout<<endl;

    }

 

private:

    static int alloc;

    int num;

    char name[10];

};

 

int A::alloc=0;

 

int main()

{

    A *a=new A;  //实参实际上为sizeof(A)

 

    a->init(5);  //给分配的前五个元素赋初值，剩余元素赋0

    a->show();

 

    delete a;

 

    return 0;

}

 

 

 

 

4.虚函数与虚表指针

//virtual.cpp

 

 

#include<iostream>

using namespace std;

 

class A{

    int d;

public:

    virtual void f(){cout<<"A类的虚函数"<<endl;}

    virtual void g(){cout<<this<<","<<&d<<endl;}

    int* get_d(){return &d;}

};

 

class B:public A{

    int d;

public:

    void f(){cout<<"B类的虚函数"<<endl;}

    void g(){cout<<this<<","<<get_d()<<endl;}

    void k(){}

    void m(){}

    void n(){} 

};

 

int main()

{

    A *p=new A;

    A *q=new B;

 

    p->f();  //输出:A类的虚函数

    q->f();  //输出:B类的虚函数

   

    p->g();

    q->g();

 

    memcpy(q,p,4);//让q所指对象的虚表指针指向A类

    q->f();  //输出:A类的虚函数

   

    delete p;

    delete q;

 

    cout<<"================="<<endl;

    cout<<sizeof(A)<<endl;

    cout<<sizeof(B)<<endl;

    cout<<"================="<<endl;

 

    return 0;

}