Assignment Operator and Pointer

Peter_APIIT · #1 03-Sep-2007, 19:47

Recently, i have found out one article where best explained the assignment operator where you can found at
http://www.icu-project.org/docs/pape..._operator.html

This article describes the underlying C++ memory management and assignment operator.

Basically, i not very understand the whole articles.

I still prefer to have some picture.

Consider the following class definition:

CPP / C++ / C Code:

class TFoo : public TSuperFoo {
    TBar* fBar1;
    TBar* fBar2;
    // various method definitions go here...
}

You have a class, TFoo, which descends from a class, TSuperFoo, and which has two data members, both of which are pointers to objects of class TBar. For the purposes of this exercise, consider both pointers to have owning semantics and TBar to be a monomorphic class. Write the assignment operator for this class.

Solution:

CPP / C++ / C Code:

TFoo&
TFoo::operator=(const TFoo& that)
{
    if (this != &that) {
        TBar* bar1 = 0;
        TBar* bar2 = 0;

        try {
            bar1 = new TBar(*that.fBar1);
            bar2 = new TBar(*that.fBar2);
        }
        catch (...) {
            delete bar1;
            delete bar2;
            throw;
        }

        TSuperFoo::operator=(that);
        delete fBar1;
        fBar1 = bar1;
        delete fBar2;
        fBar2 = bar2;
    }
    return *this;
}

As far as i know, owner pointer is the first pointer to the object and aliasing pointer is the second pointer pointed to the object. (Correct me if i wrong)

CPP / C++ / C Code:

nt number = 1;

int *ptr1; 
ptr1 = &number; // Owner Pointer

int *ptr2;
ptr2 = &number;  // Aliasing pointer

Please correct me if i wrong.

I don't understand the operation of the code.
Therefore, i hope someone will get clear my doubts.

My Question is i don't understand the algorithm inside the assignment operator.

Why we need to delete before copied ? After delete the memory, how we can copy to another object ?

CPP / C++ / C Code:

A& A:perator=(const A& rhs)
{
if(this!=&rhs)
{
setData(rhs.m_name);
}
return *this;
}
// -----------------------------------------
void A::setData(const char *sentence)
{
if(m_name)
{
delete [] m_name;
m_name = 0;
}

m_name = new char[strlen(sentence)+1];
strcpy(m_name,sentence);
}

I hope you all can help me out because i have post the same thread more than 4 forums.

Thanks for your help.

Your help is greatly appreciated by me and others.

Peter_APIIT · #2 07-Sep-2007, 20:05

I know i should not urge for help but i really need your help.

I hope you all can help me.

Please help me.
Thanks.

#3 08-Sep-2007, 06:45

Quote:

Originally Posted by Peter_APITT

My Question is i don't understand the algorithm inside the assignment operator.

Why we need to delete before copied ? After delete the memory, how we can copy to another object ?

You need to look at the assignment operator!

CPP / C++ / C Code:

A& A::operator=( const A& rhs )

We are taking a const reference to the type. However, when we delete the memory pointed to by m_name, we're deleting whatever memory was allocated by the this instance of A not the instance of the reference we received in this operation. How do we know that? Because we checked it!

CPP / C++ / C Code:

    if( this != &rhs )

We are "freeing" this.m_name NOT rhs.m_name. In fact, since rhs is const, we can not free it. So when we invoke:

CPP / C++ / C Code:

    setData( rhs.m_name );

...we are passing in rhs.m_name, but we are deleting this.m_name:

CPP / C++ / C Code:

void A::setData( const char* sentence )
{
    if( m_name )  // this.m_name
    {
        delete [] m_name;
        m_name = 0;
    }

    m_name = new char[strlen(sentence)+1];
    strcpy(m_name, sentence); // this.m_name, rhs.m_name
}

Since we don't see how the ctor was implemented, we can only assume that the memory for m_name was dynamically allocated in the ctor (or the pointer is assigned as NULL). Furthermore, since there is no defined "setName" operation, we don't know what to expect for sure, however, we should see something very similar to this assignment operator in that setName would check to see if there was a valid m_name pointer, if so, delete it, then allocate new memory for the char* passed in on the SetName call and then strcpy the passed in value to the m_name. In fact, we'd probably expect setData to be a private operation and setName to be a public operation that simply invokes setData. ...unless, of course, m_name should really be "m_data" or setData should really be "setSentence" or whatever! It is relatively impossible to know what would be appropriate when using bogus names like "A" for the class name...when you have "conflicting" names at work.

I'd recommend using more whitespace in the code that you post so that it is clearer to see all of the operators and the interactions within the code.

:davis:

Peter_APIIT · #4 08-Sep-2007, 20:54

The program is as below:

CPP / C++ / C Code:

class A 
{ 
	char* m_name;         
public:
	abc
    A(){ m_name = 0; }
    A(const char* n)
    {
		m_name = new char[strlen(n)+1];
		strcpy(m_name,n);
	}

  /*A& operator = (const A& obj)
    {
		if( this != &obj )
        {
			setData(obj.m_name);
        }
  
        return *this;
  
      }
    */
  
   void setData(const char* n)
   {
     if( m_name )
     {
        delete m_name;
        m_name = 0;
     }
  
     m_name = new char[strlen(n)+1];
     strcpy(m_name,n);
    }
  
    void displayData()
    {
      if( m_name )
  
       cout<<"Name:"<<m_name<<endl;
  
     }
  
};
  
int main()
{
  
   A a1;

   a1.setData( "HELLO" );
   a1.displayData();
  
   A a2;
  
   a2.setData( "WORLD" );
   a2.displayData();
  
   a2 = a1;
  
   cout<<"After =:"<<endl;

   a1.displayData();
   a2.displayData();
   a1.setData( "FANTASTIC" );
   a1.displayData();
   a2.displayData();   
 
   return 0;
  
}

Can you provide me the explicit call of below ?
A second, first;
second = first;

Therefore, i can even understand better.

As far as i know, when we invoked a member function, the instance of the class is a implicit this pointer. Do i correct ?

Can u explain detail from the explicit call to the assignment operator ?

I will very appreciated your help.

Thanks for your help.

#5 09-Sep-2007, 14:22

Quote:

Originally Posted by Peter_APIIT

The program is as below:

CPP / C++ / C Code:

class A 
{ 
	char* m_name;         
public:
	abc
    A(){ m_name = 0; }
    A(const char* n)
    {
		m_name = new char[strlen(n)+1];
		strcpy(m_name,n);
	}

  /*A& operator = (const A& obj)
    {
		if( this != &obj )
        {
			setData(obj.m_name);
        }
  
        return *this;
  
      }
    */
  
   void setData(const char* n)
   {
     if( m_name )
     {
        delete m_name;
        m_name = 0;
     }
  
     m_name = new char[strlen(n)+1];
     strcpy(m_name,n);
    }
  
    void displayData()
    {
      if( m_name )
  
       cout<<"Name:"<<m_name<<endl;
  
     }
  
};
  
int main()
{
  
   A a1;

   a1.setData( "HELLO" );
   a1.displayData();
  
   A a2;
  
   a2.setData( "WORLD" );
   a2.displayData();
  
   a2 = a1;
  
   cout<<"After =:"<<endl;

   a1.displayData();
   a2.displayData();
   a1.setData( "FANTASTIC" );
   a1.displayData();
   a2.displayData();   
 
   return 0;
  
}

Can you provide me the explicit call of below ?
A second, first;
second = first;

Therefore, i can even understand better.

As far as i know, when we invoked a member function, the instance of the class is a implicit this pointer. Do i correct ?

Can u explain detail from the explicit call to the assignment operator ?

I will very appreciated your help.

Thanks for your help.

I don't know exactly what you're asking. Hopefully this will help:

CPP / C++ / C Code:

#include <iostream>

using namespace std;

class Foo
{
public:
    Foo()
    {
        cout << "ctor" << endl;
    }
    Foo( Foo const& rhs )
    {
        cout << "cctor" << endl;
    }
    Foo& operator=( Foo const& rhs )
    {
        cout << "assignment" << endl;
        if( this != &rhs )
        {}
        return *this;
    }
    virtual ~Foo()
    {
        cout << "dtor" << endl;
    }
};

int main()
{
    Foo bar1, bar2;
    bar1 = bar2;
    Foo bar3 = bar1;

    return 0;
}

Output:

Code:

ctor
ctor
assignment
cctor
dtor
dtor
dtor

ctor <---> bar1
ctor <---> bar2
assignment <---> bar1 = bar2
cctor <---> Foo bar3 = bar1

dtor <---> bar1 going out of scope
dtor <---> bar2 going out of scope
dtor <---> bar3 going out of scope

:davis:

Peter_APIIT · #6 09-Sep-2007, 21:51

For instance, this statement
string final = first + second;
is equal to the explicit call as below.

first.operator+(second). Therefore, i need to know the explicit call of assignment operator.

What is the difference between shadow copy and deep copy ?

Picture explanation is greatly appreciated by me and others.
How to represent in C++ code ?

Thanks for your help.

#7 10-Sep-2007, 06:38

Quote:

Originally Posted by Peter_APIIT

Therefore, i need to know the explicit call of assignment operator.

The assignment operator has a signature that looks like:

CPP / C++ / C Code:

ClassName& operator( ClassName const& );

Quote:

Originally Posted by Peter_APIIT

What is the difference between shadow copy and deep copy?

In a class where a member is a pointer type, a shallow (not shadow) copy is where the cctor copies only the pointer, not what is being "pointed to." A "deep" copy is when what is being pointed to is also copied. This is made rather obvious in the case of the char* member pointer. The copy and the original both point to the same memory. When the original or the copy goes away, the other now points to "bad" memory.

In the case of a cctor (also assignment operator) that is not implemented by user defined code, that is, the default cctor is used, what happens is that the compiler simply copies the pointer of first to the member pointer of second. In a case where dynamic memory is used and deleted in the dtor, then a double "free" is encountered, since the dtor of first will delete the pointer and second's dtor will try again to delete a copy of a pointer with the same value as first's.

Quote:

Originally Posted by Peter_APIIT

Picture explanation is greatly appreciated by me and others.

See: www.fredosaurus.com

...for a very simple explanation. Sorry, no pictures, though.

Quote:

Originally Posted by Peter_APIIT

How to represent in C++ code?

How to represent shallow and deep copies? Shallow copies are inherently dangerous and very likely to cause a segfault or at least a double free situation. Here is an example that attempts to free the same memory twice, which is just one of the potential hazards of a shallow copy.

shallow.cpp

CPP / C++ / C Code:

#include <iostream>
#include <cstring>

using namespace std;

class Foo
{
public:
    Foo() : m_name( 0 ){}
    virtual ~Foo()
    {
	if( m_name )
	{
	    delete [] m_name;
	    m_name = 0;
	}
    }
    void setName( char const* name )
    {
	if( m_name )
	{
	    delete [] m_name;
	}
	m_name = new char[strlen(name)+1];
	strcpy( m_name, name );
    }
    const char* getName() const
    {
	return m_name;
    }
private:
    char* m_name;
};

int main()
{
    Foo f1;
    f1.setName( "Bar" );

    Foo f2 = f1; // explicit cctor invocation

    cout << f1.getName() << endl;
    cout << f2.getName() << endl;

    return 0;
}

...here is an example that performs the deep copy/assignment:

deep.cpp

CPP / C++ / C Code:

#include <iostream>
#include <cstring>

using namespace std;

class Foo
{
public:
    Foo() : m_name( 0 ){}
    Foo( Foo const& rhs ) : m_name(0)
    {
	setName( rhs.m_name );
    }
    Foo& operator=( Foo const& rhs )
    {
	if( this != &rhs )
	{
	    if( m_name )
	    {
		setName( rhs.m_name );
	    }
	}
	return *this;
    }
    virtual ~Foo()
    {
	if( m_name )
	{
	    delete [] m_name;
	    m_name = 0;
	}
    }
    void setName( char const* name )
    {
	if( m_name )
	{
	    delete [] m_name;
	}
	m_name = new char[strlen(name)+1];
	strcpy( m_name, name );
    }
    const char* getName() const
    {
	return m_name;
    }
private:
    char* m_name;
};

int main()
{
    Foo f1;
    f1.setName( "Bar" );

    Foo f2 = f1; // explicit cctor invocation

    cout << f1.getName() << endl;
    cout << f2.getName() << endl;

    Foo f3;
    f3.setName( "BarBar" );

    f1 = f3; // explicit assignment operator invocation

    cout << f1.getName() << endl;
    cout << f3.getName() << endl;

    return 0;
}

:davis:

Peter_APIIT · #8 10-Sep-2007, 21:00

I really need to understand this issue because this is very basic and important.

FOr instnace, A first, second;

second= first;
Explicit call of assignment operator.

second.operator(first). I don't know whether i correct.

In the assignment operator, since we delete the this pointer which in this case is second. Why we need to delete the second->ptr memory. Is something wrong with my explicit call of assignment operator ?

Thanks for your help.

A picture explanation on how to operation worked is greatly appreciated by me and others as well.

A billion thank to your help and explanation.

Thanks for your hep.

#9 11-Sep-2007, 06:39

Quote:

Originally Posted by Peter_APIIT

I really need to understand this issue because this is very basic and important.

FOr instnace, A first, second;

second= first;
Explicit call of assignment operator.

second.operator(first). I don't know whether i correct.

second.operator=( first ) ...is the operation that is invoked in second = first.

Quote:

Originally Posted by Peter_APIIT

In the assignment operator, since we delete the this pointer which in this case is second. Why we need to delete the second->ptr memory. Is something wrong with my explicit call of assignment operator ?

You don't delete the this pointer. You delete the MEMBER POINTER that represents the dynamic memory contained within the class. The assignment operator and deleting the member pointer are different issues. If the class doesn't contain any members that are pointers to dynamically allocated memory, then there is no issue of shallow/deep copy and no issue of deleting the member pointer's memory.

CPP / C++ / C Code:

delete [] this->m_name;

Quote:

Originally Posted by Peter_APIIT

A picture explanation on how to operation worked is greatly appreciated by me and others as well.

A billion thank to your help and explanation.

Thanks for your hep.

Why are you repeating the previous post? I realize that you prefer to have a picture. Imagine the picture. Two different classes, both have a pointer to the same memory as pointed to by some MEMBER POINTER. One of these classes goes out of scope, and therefore, its dtor is invoked causing the memory pointed to by its member pointer to be deleted. However, the other class has not gone out of scope and tries to access its member pointer to the same memory location, but that memory location now contains invalid data because the previous class deleted it when it went out of scope.

That is only one example of the problems of a shallow copy. There are numerous others. The "double delete" where the first class goes out of scope and deletes its member pointer, then the second class goes out of scope and tries to delete its copy of the pointer is another problem.

:davis:

Peter_APIIT · #10 13-Sep-2007, 04:00

I really appreciated you explanation. I understand what u mentioned in post 9 but not the whole concept of assignment operator.

Why u delete the second Member pointer ? Do i should create a new sources of first and let second point to it without worry the double delete and dangling pointer.

Sorry for my stupidity.

A billion thanks for your help.

Linux guys have more technical knowledge over window guys.

You are really a brilliant programmer.

Thread Tools	Search this Thread
Show Printable Version Email this Page	Search this Thread: Advanced Search
Rate This Thread
Rate This Thread:

Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer

Re: Assignment Operator and Pointer