module 2

Question 1

Write the matching destructor for this constructor:

T* p = new T;

Answer 1

delete p;

Question 2

Write the matching destructor for this constructor:

T* p = new T[n];

Answer 2

delete []p;

Question 3

Write an overloaded operator new(size_t) using the <cstdlib>

Answer 3

#include <cstddef>
#include <cstdlib>
using namespace std;
void* operator new(size_t data_size) {
     void* p = malloc(data_size);
     return p;
}

Question 4

Write an overloaded operator delete(void*) using the <cstdlib>

Answer 4

#include <cstdlib>
void operator delete(void* data_ptr) {
     free(data_ptr);
}

Question 5

Write a function called punning() that takes an int as a parameter and outputs the bytes using pointer punning.

view the bytes with a decimal base

Answer 5

#include <iostream>
using namespace std;

void punning(int num) {
    char* p = reinterpret_cast<char*>(&num);
    for (int i = 0; i < sizeof(int); ++i) {
        cout << int(p[i]) << " ";
    }
}

Question 6

Overload the operator new() and operator delete() as non-public class allocation funcitons in class C to disallow allocating objects on the heap.

Answer 6

class C {
private:
   void* operator new(size_t){
	      return nullptr;
    }
    void operator delete(void*) {}
};

Question 7

What is the output of the following code?

#include <iostream>
using namespace std;

int counter() {
    static int count{0};
    return ++count;
}
int main() {
    for (int i = 0; i < 5; ++i) {
        cout << counter() << ' ';
    }
}

Answer 7

1 2 3 4 5

Question 8

Write a simple fibonacci function

Answer 8

#include <iostream>
using namespace std;

int fibonacci() {
    static int cur{0};
    static int next{1};
    
    int result = cur;
    int temp = next;
    next += cur;
    cur = temp;
    return result;
}

Question 9

What is the output of the following code?

#include <iostream>
using namespace std;
class Member1
{
public:
   Member1() {cout << "Constructing a Member1 object\n";}
};
class Member2 {
public:
   Member2() {cout << "Constructing a Member2 object\n";}
};
class Wrapper {
   Member2 mem2;
   Member1 mem1;
public:
   Wrapper() {cout << "Constructing a Wrapper\n";}
};
int main() {
   Wrapper w;
}

Answer 9

Constructing a Member2 object
Constructing a Member1 object
Constructing a Wrapper

Question 10

Write a deep copy constructor for the following class:

#include <cstring>
using namespace std;

class String {
    char* data;
public:
    String(const char* s = "") {
        data = new char[strlen(s) + 1];
        strcpy(data,s);
    }
    ~String() {delete [] data;}
};

Answer 10

String(const String& s) {
      data = new char[strlen(s.data) + 1];
      strcpy(data, s.data);
 }

Question 11

What is the compiler-generated Copy Constructor for the following class?

#include <cstring>
using namespace std;

class String {
    char* data;
public:
    String(const char* s = "") {
        data = new char[strlen(s) + 1];
        strcpy(data,s);
    }
    ~String() {delete [] data;}
};

Answer 11

String(const String& s) : data(s.data) {}

a shallow copy

Question 12

What is the compiler-generated assignment operator= for the following class:

#include <cstring>
using namespace std;

class String {
    char* data;
public:
    String(const char* s = "") {
        data = new char[strlen(s) + 1];
        strcpy(data,s);
    }
    ~String() {delete [] data;}
    String(const String& s) {
        data = new char[strlen(s.data) + 1];
        strcpy(data, s.data);
    }
};

Answer 12

String& String::operator=(const String& s) {
      data = s.data;
      return *this;
}

Question 13

Correctly overwrite the assignment operator= for the following class:

#include <cstring>
using namespace std;

class String {
    char* data;
public:
    String(const char* s = "") {
        data = new char[strlen(s) + 1];
        strcpy(data,s);
    }
    ~String() {delete [] data;}
    String(const String& s) {
        data = new char[strlen(s.data) + 1];
        strcpy(data, s.data);
    }
};

Answer 13

String& operator=(const String& s) {
     if (&s != this) {
         char* new_data = new char[strlen(s.data) + 1];
         strcpy(new_data, s.data);
         delete [] data;
         data = new_data;
     }
     return *this;
 }

Question 14

Define a struct that will keep the Synthesized Default Constructor

Answer 14

struct S {
     S() = default;
}