About smart pointers

Question

0.00/5 (No votes)

See more:

My question is about the copy constructor and operator = overload in this code. I uderstand it but not perfectly. Can someone explain me that two expressions? Thanks in advance!!!

C++

#include <iostream>
using namespace std;

template <class T>

class Auto_ptr2{
private:
    T *m_ptr;
public:
    Auto_ptr2(T *ptr=nullptr)
    {


    }
    ~Auto_ptr2(){
    delete m_ptr;
    }
    Auto_ptr2(Auto_ptr2 &p)
    {
        m_ptr=p.m_ptr;
        p.m_ptr=nullptr;


    }
    Auto_ptr2 operator=(Auto_ptr2 &p)
    {
        if(&p==this){return *this;}
        else{
            delete m_ptr;
            m_ptr=p.m_ptr;
            return *this;

        }

    }
    T &operator*(){return *m_ptr;}
    T *operator->(){return m_ptr;}
bool isNull()const{return m_ptr==nullptr;}
};

class Resource{
public:
    Resource(){cout<<"Resource is acquired"<<endl;}
    ~Resource(){cout<<"Resource is destroyed"<<endl;}


};


int main()
{
    Auto_ptr2<Resource> res1(new Resource);
    Auto_ptr2<Resource> res2;
    cout<<"res1 is: "<<(res1.isNull()?"null":"not null")<<endl;
    cout<<"res2 is: "<<(res2.isNull()?"null": "not null")<<endl;
    res2=res1;
    cout<<"res1 is: "<<(res1.isNull()?"null":"not null")<<endl;
    cout<<"res2 is: "<<(res2.isNull()?"null": "not null")<<endl;


}

What I have tried:

I have tried to understand it, I understand it now, but not perfectly :)

Posted 24-Jun-17 21:47pm

Member 13277493

Updated 25-Jun-17 1:49am

Add a Solution

Comments

Philippe Mori 25-Jun-17 7:45am

Standard auto_ptr class has known problems... so your code based on its implementation. If you have a modern C++ compiler, better to use unique_ptr or shared_ptr instead.

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

KarstenK · Answer 1 · 2017-06-24T22:45:00

In the copy and constructor are assigments of the member pointer, which contains the raw pointer. But these arent not only pointers, but also allocated memory which must get handled seperatly.

I would judge them a wrong, by not making a deep copy but deleting the right side.

My implementation

C++

Auto_ptr2(const Auto_ptr2 &p)
{
    m_ptr= MakeCopy( p.m_ptr );//make a full copy of object
    //p.m_ptr=nullptr;
}
Auto_ptr2 operator=(const Auto_ptr2 &p)
{
    if(&p==this){return *this;}
    else{
        delete m_ptr;//correct deleting the old raw copy
        m_ptr=MakeCopy( p.m_ptr );
        return *this;
    }
}

Another solution can be the so called reference counting architecture, when a counter is used to controls the lifecycle of the raw pointer data.

Philippe Mori · Answer 2 · 2017-06-25T01:49:00

Solution 2

Essentially auto_ptr was an attempt to move ownership before C++ 11. However, that implementation has known problems because the language at that time didn't yet have rvalue reference and move semantic...

If possible use std::unique_ptr or std::shared_ptr.

Posted 25-Jun-17 1:49am

Philippe Mori