Assignment operator

[arashmath]

Hi,
How can i use default assignment operator (member-by-member assignment) after overloading this operator?
I want to access orginal version of assigment operator (=),
but i don't know the syntax that imply compiler to use default version and not to use overload version.

[RRick]

I'm not sure what you want to do with operator=. It's not usually overwritten and picking specific operator='s sounds like trouble.

Can you give an example of what you're trying to do?

[arashmath]

I have code like this:

#include <stdio.h>
#include <conio.h>
#include <mem.h>

void swap_int( int& int1 , int& int2 ) // A funtion that swap tow integers.
{
   int temp = int1;
   int1 = int2;
   int2 = temp;
}

class MyClass
{
  private:
      double *Val_; // Value data pointer
      int ValLength_; // Lenght of value data
      int Var1_;
      int Var2_;
      int Var3_; // and may be more declaration
  public:
      MyClass() { Val_ = NULL; ValLength_ = 0; }  // Default constructor
      MyClass( int Len ) { Val_ = new double[Len]; ValLength_ = Len; }
      ~MyClass() { if(Val_!=NULL) delete[] Val_; } // Free memory

      MyClass& operator=(const MyClass& MC) // Here i overwrite operator =
      {
         if(Val_!=NULL) delete[] Val_;
         Val_ = new double[MC.ValLength_];
         memcpy( Val_ , MC.Val_ , sizeof(double)*MC.ValLength_ );
         ValLength_ = MC.ValLength_;
         Var1_ = MC.Var1_;
         Var2_ = MC.Var2_;
         Var3_ = MC.Var3_;
         return *this;
      }
      // Now three methods for exchange MC1 , MC2
      friend void swap1( MyClass& MC1 , MyClass& MC2 );
      friend void swap2( MyClass& MC1 , MyClass& MC2 );
      friend void swap3( MyClass& MC1 , MyClass& MC2 );
};

void swap1( MyClass& MC1 , MyClass& MC2 )
{  /* This method performance is slow because it use overwritten version
       for assignment operator */
  MyClass temp = MC1;
  MC1 = MC2;  
  MC2 = temp;
}

void swap2( MyClass& MC1 , MyClass& MC2 )
{  // This one is much faster than swap1 and its result is same as swap1.
  double *temp = MC1.Val_;
  MC1.Val_ = MC2.Val_;
  MC2.Val_ = temp;
  swap_int( MC1.ValLength_ , MC2.ValLength_ );
  swap_int( MC1.Var1_ , MC2.Var1_ );
  swap_int( MC1.Var2_ , MC2.Var2_ );
  swap_int( MC1.Var3_ , MC2.Var3_ );
}
void swap3( MyClass& MC1 , MyClass& MC2 )
{  /* Here i try improve swap2.
      if there was no user-defined operator =, the operator = would define by
      default as a member-by-member assignment of the members of class.
      But in MyClass operator = is overwritten.
      I want compliler use default version assignment in these codes:

	MyClass temp = MC1;
	MC1 = MC2;
	MC2 = temp;

      How can i do this? */
}

int main()
{
	MyClass MC1(10000000) , MC2(5000000);
	printf("swap1 Starts...\n");
	swap1( MC1 , MC2 );
	printf("swap2 Starts...\n");
	swap2( MC1 , MC2 );
	printf("swap3 Starts...\n");
	swap3( MC1 , MC2 );
 	printf("Done!\n");
                getch();
	return 0;
}

I explain the problem in line 61.

Thanks. :)

[mickey0]

This maybe will help you; But there were some errors:

#ifndef MY_CLASS_H
#define MY_CLASS_H

class MyClass {
  private:
      double *Val_; // Value data pointer
      int ValLength_; // Lenght of value data
      int Var1_;

  public:
          //important: initialize the pointer to NULL:
	  MyClass(): Var1_( 0 ), ValLength_( 0 ), Val_( 0 ) { }   

	  MyClass( int len, int var1 = 0 ): Var1_( var1 ), ValLength_( len ), 
                     Val_( new double[len]) { 
		  puts("MyClass::MyClass()");
                  //memset is not necessary
		  memset(Val_, 0, sizeof(double)*len); //set all value to '0'
	  }   

      ~MyClass() { 	
			puts("MyClass::~MyClass()");
			//if(Val_!=NULL) //unuseful: if (Val_ == NULL), 
                        //the 'delete[] Val_' doens't throw an error.
			delete[] Val_; 
	  } 
      
	  //copy constructor is needed for 'MyClass temp = MC1';
	  MyClass (const MyClass& mc) : Var1_ (mc.Var1_),  
          ValLength_(mc.ValLength_), Val_(new double[mc.ValLength_]) {
		   puts("MyClass::MyClass(const MyClass& mc)");
		  memcpy (Val_, mc.Val_, sizeof(double) * mc.ValLength_);		
	  }

	  MyClass& operator=(const MyClass& MC) {
	     if (this == & MC) return *this; //check this

		 delete[] Val_;
		 Val_ = new double[MC.ValLength_];			   
         memcpy( Val_ , MC.Val_ , sizeof(double) * MC.ValLength_ );
         ValLength_ = MC.ValLength_;
         Var1_ = MC.Var1_;        
         return *this;
      }

      // Now three methods for exchange MC1 , MC2
      friend void swap1( MyClass& MC1 , MyClass& MC2 );
      friend void swap2( MyClass& MC1 , MyClass& MC2 );
      friend void swap3( MyClass& MC1 , MyClass& MC2 );
};


// A funtion that swap tow integers.
void swap_int( int& int1 , int& int2 ) {
   int temp = int1;
   int1 = int2;
   int2 = temp;
}

void swap1(MyClass& MC1 , MyClass& MC2 ) {   
  MyClass temp = MC1;
  MC1 = MC2; 
  MC2 = temp;
}
 
void swap2( MyClass& MC1 , MyClass& MC2 ) {  

  double *temp = MC1.Val_;
  MC1.Val_ = MC2.Val_;
  MC2.Val_ = temp;
  swap_int( MC1.ValLength_ , MC2.ValLength_ );
  swap_int( MC1.Var1_ , MC2.Var1_ );
}

void swap3( MyClass& MC1 , MyClass& MC2 ) {  
	/* 
	the default operator= won't work; what do you want?
	Do you want MC2.Val_ points to temp memory  block? In the case, 
        when you exit from this scope temp destructor is called BUT
	MC2 points again to undefined block of memory; when MC2 destructor 
        will called, the delete will cause a runtime error;
	What you want to obtain doens't make sense; when there are 
        pointers inside a class operator= redefinition is necessary, not optional
	*/

	/*
    MyClass temp = MC1;
    MC1 = MC2;
    MC2 = temp;
    How can i do this? */
}

#endif MY_CLASS_H

int main (int argc, char** argv) {
    MyClass MC1(10000000, 99) , MC2(5000000, 11);
    printf("swap1 Starts...\n");
    swap1( MC1 , MC2 ); 
    printf("swap2 Starts...\n");
    swap2( MC1 , MC2 );    
    return EXIT_SUCCESS;
}

[weaknessforcats]

How can i use default assignment operator (member-by-member assignment) after overloading this operator?

You can't. The default assignment operator is simply member by member assignment. When you write your own operator=, you have to assume responsibility for assigning all class members and not just a few of them.

Typically, you don't need an operator= overload unless there are class members that need resource allocations or where a class member is a pointer and you don't want to just assign rthe pointer. This second case depends upon what you are doing.

[arashmath]

Thanks everyone for their help.