#include<iostream>
#include<vector>
using namespace std;

class A
{
public:
    A(){}
    ~A(){}
    virtual void func()
    { cout<<"A"<<endl;}
};

class B: public A
{
public:
    B(){}
    ~B(){}
    void func()
    { cout<<"B"<<endl;}
};

int main()
{
    A a;
    B b;
    vector<A> vec;
    vec.push_back(a);
    vec.push_back(b);
    vec[0].func();
    vec[1].func();
}

#include<iostream>
#include<vector>
using namespace std;

class A
{
public:
    A(){}
    ~A(){}
    virtual void func() const
    { cout<<"A"<<endl;}
    virtual A* clone() const //为了实现句柄类新增的函数
    { return new A(*this);}
};

class B: public A
{
public:
    B(){}
    ~B(){}
    void func() const
    { cout<<"B"<<endl;}
    virtual B* clone() const //为了实现句柄类新增的函数
    { return new B(*this);}
};


class sample
{
public:
    sample(): p(0),use(1){}
    sample(const A& a):p(a.clone()){use++;} //引用构造
    sample(const sample& i):p(i.p),use(i.use){use++;} //引用构造
    
    ~sample() {decr_use();}
    
    sample& operator=(const sample &i)
    {
        use++;
        decr_use();
        p = i.p;
        use = i.use;
        return (*this);
    }
    
    const A* operator->() const
    {return p;}
    
    const A& operator*() const
    {return *p;}
    
private:
    A* p;
    size_t use;
    void decr_use(){if(--use==0) delete p;}
    
};
int main()
{
    vector<sample> vec; //sample类看起来是对象，但是其实用法和指针一样。
    A a;
    B b;
    sample s1(a); //将a拷贝构造了一个新对象，并让s1指向这个新的对象。此时s1已经与a无关了。
    sample s2(b); //将b拷贝构造了一个新对象，并让s2指向这个新的对象。此时s2已经与b无关了。
    vec.push_back(s1);
    vec.push_back(s2);
    vec[0]->func();
    vec[1]->func();
}

#include<iostream>
#include<vector>
using namespace std;

class A
{
public:
    A(){numA = 0;}
    ~A(){}
    virtual void func() const
    { cout<<"A"<<endl;}
    virtual A* clone() const //为了实现句柄类新增的函数
    { return new A(*this);}
    
    void setNum(int n) //增加了一个设置num属性的函数
    { numA = n;}
    
    int getNum() const
    { return numA;}
private:
    int numA;
};

class B: public A
{
public:
    B(){numB = 0;}
    ~B(){}
    void func() const
    { cout<<"B"<<endl;}
    virtual B* clone() const //为了实现句柄类新增的函数
    { return new B(*this);}
    
    void setNum(int n) //增加了一个设置num属性的函数
    { numB = n;}
    
    int getNum() const
    { return numB;}
private:
    int numB;
};


class sample
{
public:
    sample(): p(0),use(1){}
    sample(const A& a):p(a.clone()){use++;} //引用构造
    sample(const sample& i):p(i.p),use(i.use){use++;} //引用构造
    
    ~sample() {decr_use();}
    
    sample& operator=(const sample &i)
    {
        use++;
        decr_use();
        p = i.p;
        use = i.use;
        return (*this);
    }
    
    A* operator->() const
    {return p;}
    
    A& operator*() const
    {return *p;}
    
private:
    A* p;
    size_t use;
    void decr_use(){if(--use==0) delete p;}
    
};

void changeA(sample sam)
{
    sam->setNum(6);
}

int main()
{
    A a;
    sample s1(a);
    
    cout<<"s1中num的值： "<<s1->getNum()<<endl;
    cout<<"a的num值： "<<a.getNum()<<endl;
    
    changeA(s1);
    
    cout<<"更改后s1中num的值： "<<s1->getNum()<<endl;
    cout<<"更改后a的num值： "<<a.getNum()<<endl;
    
}