Scribd
Upload
12 views

Assignment and Copy Initialization in C

Good for assignment and copy operator in cpp

Uploaded by

parshantgoyal69
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
12 views

Assignment and Copy Initialization in C

Good for assignment and copy operator in cpp

Uploaded by

parshantgoyal69
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

Assignment and Copy Initialization in C++

1. Assignment in C++

 Assignment is the process of copying the contents of one object into


another existing object of the same type.
 In C++, this is usually done using the assignment operator (`=`). By
default, C++ provides a built-in assignment operator for each class, which
performs shallow copying (member-wise copying).

a. Default Assignment Operator:


 By default, C++ generates an assignment operator for each class that
performs a member-wise assignment. For simple data types like `int` or
`double`, this is often enough.
 However, for classes that allocate dynamic memory (e.g., via pointers),
it's usually necessary to overload the assignment operator.
b. Overloading the Assignment Operator:
 When you need deep copying (especially when dynamic memory is
involved), you need to overload the assignment operator.
 This allows you to properly manage resources, avoid memory leaks, and
handle issues like self-assignment.
Syntax for Overloading the Assignment Operator:
class MyClass { }
int* data; // Pointer to dynamically allocated memory
// Display the value
public: void display() const {
// Constructor std::cout << "Value: " << *data << std::endl;
MyClass(int val) { }
data = new int(val); };
}
// Destructor int main() {
~MyClass() { MyClass obj1(10);
delete data; MyClass obj2(20);
}
// Copy Assignment Operator obj1.display(); // Output: Value: 10
MyClass& operator=(const MyClass& other) { obj2.display(); // Output: Value: 20
if (this != &other) { // Check for self-assignment
// Release the existing memory obj2 = obj1; // Assign obj1 to obj2
delete data;
// Allocate new memory and copy obj1.display(); // Output: Value: 10
data = new int(*(other.data)); obj2.display(); // Output: Value: 10
} }
return *this;
2. Copy Initialization in C++

Copy Initialization is the process of creating a new object by copying an


existing object. This usually happens when:

1. You create a new object and initialize it with another object.

2. An object is passed by value to a function.

3. An object is returned by value from a function.

Copy initialization uses the copy constructor (or the move constructor, if
applicable). If a class doesn't define a copy constructor, C++ provides a default
one that performs shallow copying (member-wise copying).

a. Default Copy Constructor:

Similar to the assignment operator, C++ automatically generates a copy


constructor for every class that copies each data member from the source object
to the new object.

b. Custom Copy Constructor (Deep Copy):

If a class manages resources such as dynamic memory, you'll need to implement


a custom copy constructor to handle deep copying.

Syntax for a Copy Constructor:


class MyClass {
int* data; // Pointer to dynamically allocated memory // Display the value
void display() const {
public: std::cout << "Value: " << *data << std::endl;
// Constructor }
MyClass(int val) { };
data = new int(val);
} int main() {
MyClass obj1(30); // Constructor called
// Destructor MyClass obj2 = obj1; // Copy constructor called
~MyClass() {
delete data; obj1.display(); // Output: Value: 30
} obj2.display(); // Output: Value: 30
}
// Copy Constructor
MyClass(const MyClass& other) {
// Allocate new memory and copy the data
data = new int(*(other.data));
}
Key Points:

1. Deep Copying: The copy constructor creates a new memory block and copies
the data from the source object.

2. Copy Constructor Invocation: The copy constructor is called when a new


object is created from an existing one, e.g., `MyClass obj2 = obj1;`.

c. Copy Constructor vs. Assignment Operator:

- Copy Constructor: Called when a new object is created and initialized using
another object (e.g., `MyClass obj2 = obj1;`).

- Assignment Operator: Called when an existing object is assigned the value of


another existing object (e.g., `obj2 = obj1;`).

Example of Copy Initialization:

class MyClass { // Display


int* data; void display() {
std::cout << "Data: " << *data << std::endl;
public: }
// Constructor };
MyClass(int val) {
data = new int(val); int main() {
} MyClass obj1(10); // Constructor called
MyClass obj2 = obj1; // Copy constructor
// Copy Constructor called (Copy Initialization)
MyClass(const MyClass& obj) {
data = new int(*(obj.data)); obj1.display(); // Output: Data: 10
} obj2.display(); // Output: Data: 10
}
// Destructor
~MyClass() {
delete data;
}

Differences between Assignment and Copy Initialization:


Practical Considerations:

- Use deep copying (via overloading the assignment operator or defining a


custom copy constructor) when your class uses dynamically allocated memory
or other resources.

- Always remember to check for self-assignment in the assignment operator to


avoid issues.

- The copy constructor is vital for passing and returning objects by value, so
ensure proper handling of resources.

You might also like