首页 > 代码库 > 标准C++之运算符重载和虚表指针

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

2024-07-26 18:39:53   218人阅读

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;
}

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


联系
我们