337 C++ (22)

Question 1

What is the following?
`
int a = 40 //???
int b;
b=a; //???
`

Answer 1

`
int a = 40 //initialization
int b;
b=a; //assignment
`

Question 2

Is the following assignment or initialization? Why or why not?
`
Aclass obj1;
Aclassobj2 = obj1
`

Answer 2

This is initialization. You may initialize the object of a class by an existing object of the same class.

Every data member of instance obj1 will be copied into instance obj2. This is called member-wise copying.

Question 3

The following lines of code are labeled 1, 2, and 3. Determine whether they call a constructor or not.
`
MyString s1(“World);
MyString s2=s1;

`

Answer 3

MyString s1(“World); //call to constructor
MyString s2=s1; //Not a call to constructor.

Question 4

What is the general format forthe declaration of a copy constructor where X is the class name.

Answer 4

`
X(const X& source);
`

Question 5

What is the format for copying an object by assignment? (Using the assignment operator)

Answer 5

X &operator = (const X&rhs);

Example
MyString &operator = (MyString& s);

MyString& MyString::operator =(const MyString& s) {
    if (this != &s) {
        delete[] storageM;  // Deallocate memory of the current object
        lengthM = s.lengthM; // Update the length
        storageM = new char[lengthM + 1]; // Allocate new memory
        assert(storageM != nullptr);  // Ensure memory allocation is successful
        strcpy(storageM, s.storageM); // Copy the content from the source to the current object
    }
    return *this; // Return a reference to the current object
}

Question 6

In the following assignment operator for copying a string, fill in the blanks
It has members storageM, and lengthM

MyString& MyString::operator =(MyString& s) {
    if (this != &s) {
        delete[] \_\_\_\_\_\_\_\_;  // Deallocate memory of the current object
        \_\_\_\_\_\_\_ = \_\_\_\_\_\_\_\_\_; // Update the length
        storageM = new char[\_\_\_\_\_\_\_\_ + 1]; // Allocate new memory
        assert(storageM != NULL);  // Ensure memory allocation is successful
        strcpy(\_\_\_\_\_\_\_, \_\_\_\_\_\_\_\_); // Copy the content from the source to the current object
    }
    return \_\_\_\_\_\_\_; // Return a reference to the current object
}

Answer 6

MyString& MyString::operator =(MyString& s) {
    if (this != &s) {
        delete[] storageM;  // Deallocate memory of the current object
        lengthM = s.lengthM; // Update the length
        storageM = new char[lengthM + 1]; // Allocate new memory
        assert(storageM != NULL);  // Ensure memory allocation is successful
        strcpy(storageM, s.storageM); // Copy the content from the source to the current object
    }
    return *this; // Return a reference to the current object
}

Question 7

In the assignment operator why do we want to avoid self copying? Let’s say we do s1 = s1; What line must we include to avoid any issues?

Answer 7

When we delete the old space, this will cause an issue for the new object. Therefore to avoid this issue we MUST include if (this != &s).

Question 8

What header file must be included in order to use the assert function?

Answer 8

You must #include <cassert>

Question 9

True or false, s1 = s3 calls the copy constructor

Answer 9

False, this is an assignment operation

Question 10

Why does a copy constructor not delete storageM but the overloaded Assignment Operator does?

Answer 10

The copy constructor is responsible for creating a new object and initializing it with the contents of an existing object. It is invoked when a new object is being created as a copy of an existing object. Since the new object is being constructed from scratch, there is no need to delete any existing memory because there is no existing memory to delete.

The overloaded assignment operator (operator=) is responsible for assigning the value of one existing object to another. When overwriting the value of an existing object, it’s crucial to first deallocate any existing memory in the destination object to avoid memory leaks. Therefore, the overloaded assignment operator often includes a delete operation to release the existing resources.

Question 11

True or false MyString s2 = s1; is a call to a copy constructor.

Answer 11

True

Question 12

What is the return value for a copy constructor?

Answer 12

It has no return value.

Question 13

For the following copy constructor, fill in the blanks:

MyString::MyString(const MyString& s) : lengthM(s.lengthM)
{

storageM = new char [\_\_\_\_\_\_\_\_+1];
assert (\_\_\_\_\_\_\_\_\_ !=0);
strcpy(\_\_\_\_\_\_\_\_\_, \_\_\_\_\_\_\_\_\_\_);

}

Answer 13

\MyString::MyString(const MyString& s) : lengthM(s.lengthM)
{

storageM = new char [lengthM+1];
assert (storageM !=0);
strcpy(storageM, s.storageM);

}

Question 14

Does a destructor return any value? Does it receive any parameter?

Answer 14

No a destructor does not return any value, and it does not receive any parameter.

Question 15

What is the general format for a destructor?

Answer 15

MyString::~MyString(){
delete[] storageM;
}

Question 16

What is object aggregation?

Answer 16

Object aggregation is when a class can contain other classes as their data member.

Example:
Person(int d, int m, int y, char* na, int a): birthday(d, m, y), age(a)
{
strcpy(name, na);
}

Question 17

What does the function prototype look for an assignment operator in C++?

Answer 17

It would look like
MyClass& operator=(const MyClass& rhs);

The actual implementation would look like:
MyClass& MyClass::operator=(const MyClass& rhs) {
// Implementation of the assignment operator
// …
return *this;
}