C++

Question 1

What is the Rule of Three in C++?

Answer 1

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 2

Explain the difference between new and malloc in C++.

Answer 2

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 3

What is RAII (Resource Acquisition Is Initialization)?

Answer 3

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 4

What is the difference between shallow copy and deep copy in C++?

Answer 4

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 5

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 5

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 6

What is the difference between std::vector and std::array?

Answer 6

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 7

What is the Rule of Three in C++?

Answer 7

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 8

Explain the difference between new and malloc in C++.

Answer 8

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 9

What is RAII (Resource Acquisition Is Initialization)?

Answer 9

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 10

What is the difference between shallow copy and deep copy in C++?

Answer 10

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 11

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 11

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 12

What is the difference between std::vector and std::array?

Answer 12

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 13

What is the Rule of Three in C++?

Answer 13

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 14

Explain the difference between new and malloc in C++.

Answer 14

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 15

What is RAII (Resource Acquisition Is Initialization)?

Answer 15

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 16

What is the difference between shallow copy and deep copy in C++?

Answer 16

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 17

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 17

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 18

What is the difference between std::vector and std::array?

Answer 18

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 19

What is the Rule of Three in C++?

Answer 19

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 20

Explain the difference between new and malloc in C++.

Answer 20

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 21

What is RAII (Resource Acquisition Is Initialization)?

Answer 21

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 22

What is the difference between shallow copy and deep copy in C++?

Answer 22

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 23

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 23

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 24

What is the difference between std::vector and std::array?

Answer 24

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 25

What is the Rule of Three in C++?

Answer 25

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 26

Explain the difference between new and malloc in C++.

Answer 26

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 27

What is RAII (Resource Acquisition Is Initialization)?

Answer 27

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 28

What is the difference between shallow copy and deep copy in C++?

Answer 28

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 29

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 29

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 30

What is the difference between std::vector and std::array?

Answer 30

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 31

What is the Rule of Three in C++?

Answer 31

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 32

Explain the difference between new and malloc in C++.

Answer 32

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 33

What is RAII (Resource Acquisition Is Initialization)?

Answer 33

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 34

What is the difference between shallow copy and deep copy in C++?

Answer 34

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 35

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 35

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 36

What is the difference between std::vector and std::array?

Answer 36

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 37

What is the Rule of Three in C++?

Answer 37

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 38

Explain the difference between new and malloc in C++.

Answer 38

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 39

What is RAII (Resource Acquisition Is Initialization)?

Answer 39

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 40

What is the difference between shallow copy and deep copy in C++?

Answer 40

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 41

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 41

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 42

What is the difference between std::vector and std::array?

Answer 42

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 43

What is the Rule of Three in C++?

Answer 43

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 44

Explain the difference between new and malloc in C++.

Answer 44

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 45

What is RAII (Resource Acquisition Is Initialization)?

Answer 45

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 46

What is the difference between shallow copy and deep copy in C++?

Answer 46

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 47

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 47

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 48

What is the difference between std::vector and std::array?

Answer 48

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 49

What is the Rule of Three in C++?

Answer 49

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 50

Explain the difference between new and malloc in C++.

Answer 50

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 51

What is RAII (Resource Acquisition Is Initialization)?

Answer 51

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 52

What is the difference between shallow copy and deep copy in C++?

Answer 52

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 53

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 53

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 54

What is the difference between std::vector and std::array?

Answer 54

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 55

What is the Rule of Three in C++?

Answer 55

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 56

Explain the difference between new and malloc in C++.

Answer 56

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 57

What is RAII (Resource Acquisition Is Initialization)?

Answer 57

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 58

What is the difference between shallow copy and deep copy in C++?

Answer 58

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 59

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 59

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 60

What is the difference between std::vector and std::array?

Answer 60

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 61

What is the Rule of Three in C++?

Answer 61

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 62

Explain the difference between new and malloc in C++.

Answer 62

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 63

What is RAII (Resource Acquisition Is Initialization)?

Answer 63

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 64

What is the difference between shallow copy and deep copy in C++?

Answer 64

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 65

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 65

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 66

What is the difference between std::vector and std::array?

Answer 66

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 67

What is the Rule of Three in C++?

Answer 67

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 68

Explain the difference between new and malloc in C++.

Answer 68

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 69

What is RAII (Resource Acquisition Is Initialization)?

Answer 69

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 70

What is the difference between shallow copy and deep copy in C++?

Answer 70

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 71

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 71

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 72

What is the difference between std::vector and std::array?

Answer 72

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 73

What is the Rule of Three in C++?

Answer 73

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 74

Explain the difference between new and malloc in C++.

Answer 74

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 75

What is RAII (Resource Acquisition Is Initialization)?

Answer 75

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 76

What is the difference between shallow copy and deep copy in C++?

Answer 76

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 77

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 77

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 78

What is the difference between std::vector and std::array?

Answer 78

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 79

What is the Rule of Three in C++?

Answer 79

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 80

Explain the difference between new and malloc in C++.

Answer 80

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 81

What is RAII (Resource Acquisition Is Initialization)?

Answer 81

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 82

What is the difference between shallow copy and deep copy in C++?

Answer 82

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 83

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 83

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 84

What is the difference between std::vector and std::array?

Answer 84

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 85

What is the Rule of Three in C++?

Answer 85

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 86

Explain the difference between new and malloc in C++.

Answer 86

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 87

What is RAII (Resource Acquisition Is Initialization)?

Answer 87

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 88

What is the difference between shallow copy and deep copy in C++?

Answer 88

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 89

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 89

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 90

What is the difference between std::vector and std::array?

Answer 90

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 91

What is the Rule of Three in C++?

Answer 91

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 92

Explain the difference between new and malloc in C++.

Answer 92

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 93

What is RAII (Resource Acquisition Is Initialization)?

Answer 93

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 94

What is the difference between shallow copy and deep copy in C++?

Answer 94

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 95

What is SFINAE (Substitution Failure Is Not An Error) in C++?

Answer 95

SFINAE is a C++ language feature that allows template specialization based on type traits or conditions without causing compilation failure.

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Integral type
";
}

template
typename std::enable_if::value, void>::type
process(T val) {
    std::cout << "Non-integral type
";
}

Question 96

What is the difference between std::vector and std::array?

Answer 96

std::vector is a dynamic array with size management, while std::array is a fixed-size array.

std::vector vec = {1, 2, 3};
std::array arr = {1, 2, 3};

Question 97

What is the Rule of Three in C++?

Answer 97

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it likely requires all three.

class Example {
    int* data;
public:
    Example(int val) : data(new int(val)) {}
    ~Example() { delete data; }
    Example(const Example& other) : data(new int(*other.data)) {}
    Example& operator=(const Example& other) {
        if (this == &other) return *this;
        *data = *other.data;
        return *this;
    }
};

Question 98

Explain the difference between new and malloc in C++.

Answer 98

new initializes objects, calls constructors, and returns a typed pointer. malloc only allocates memory and returns a void pointer.

int* p1 = new int(5); // calls constructor
int* p2 = (int*)malloc(sizeof(int)); // does not call constructor

Question 99

What is RAII (Resource Acquisition Is Initialization)?

Answer 99

RAII is a programming idiom where resources are acquired and released by objects. Resources like memory or file handles are tied to object lifetimes.

class File {
    std::ofstream file;
public:
    File(const std::string& name) { file.open(name); }
    ~File() { file.close(); }
};

Question 100

What is the difference between shallow copy and deep copy in C++?

Answer 100

A shallow copy copies only the pointer, not the object itself, while a deep copy duplicates the actual data the pointer refers to.

class Shallow {
    int* data;
public:
    Shallow(int val) : data(new int(val)) {}
    ~Shallow() { delete data; }
    Shallow(const Shallow& other) : data(other.data) {} // Shallow copy
};

class Deep {
    int* data;
public:
    Deep(int val) : data(new int(val)) {}
    ~Deep() { delete data; }
    Deep(const Deep& other) : data(new int(*other.data)) {} // Deep copy
};

Question 101

What is the difference between a deep copy and a shallow copy in C++?

Answer 101

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 102

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 102

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 103

Explain the memory layout of a C++ object.

Answer 103

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 104

How does dynamic_cast work internally?

Answer 104

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 105

What is the difference between a deep copy and a shallow copy in C++?

Answer 105

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 106

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 106

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 107

Explain the memory layout of a C++ object.

Answer 107

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 108

How does dynamic_cast work internally?

Answer 108

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 109

What is the difference between a deep copy and a shallow copy in C++?

Answer 109

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 110

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 110

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 111

Explain the memory layout of a C++ object.

Answer 111

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 112

How does dynamic_cast work internally?

Answer 112

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 113

What is the difference between a deep copy and a shallow copy in C++?

Answer 113

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 114

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 114

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 115

Explain the memory layout of a C++ object.

Answer 115

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 116

How does dynamic_cast work internally?

Answer 116

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 117

What is the difference between a deep copy and a shallow copy in C++?

Answer 117

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 118

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 118

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 119

Explain the memory layout of a C++ object.

Answer 119

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 120

How does dynamic_cast work internally?

Answer 120

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 121

What is the difference between a deep copy and a shallow copy in C++?

Answer 121

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 122

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 122

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 123

Explain the memory layout of a C++ object.

Answer 123

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 124

How does dynamic_cast work internally?

Answer 124

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 125

What is the difference between a deep copy and a shallow copy in C++?

Answer 125

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 126

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 126

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 127

Explain the memory layout of a C++ object.

Answer 127

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 128

How does dynamic_cast work internally?

Answer 128

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 129

What is the difference between a deep copy and a shallow copy in C++?

Answer 129

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 130

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 130

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 131

Explain the memory layout of a C++ object.

Answer 131

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 132

How does dynamic_cast work internally?

Answer 132

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 133

What is the difference between a deep copy and a shallow copy in C++?

Answer 133

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 134

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 134

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 135

Explain the memory layout of a C++ object.

Answer 135

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 136

How does dynamic_cast work internally?

Answer 136

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 137

What is the difference between a deep copy and a shallow copy in C++?

Answer 137

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 138

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 138

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 139

Explain the memory layout of a C++ object.

Answer 139

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 140

How does dynamic_cast work internally?

Answer 140

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 141

What is the difference between a deep copy and a shallow copy in C++?

Answer 141

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 142

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 142

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 143

Explain the memory layout of a C++ object.

Answer 143

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 144

How does dynamic_cast work internally?

Answer 144

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 145

What is the difference between a deep copy and a shallow copy in C++?

Answer 145

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 146

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 146

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 147

Explain the memory layout of a C++ object.

Answer 147

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 148

How does dynamic_cast work internally?

Answer 148

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 149

What is the difference between a deep copy and a shallow copy in C++?

Answer 149

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 150

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 150

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 151

Explain the memory layout of a C++ object.

Answer 151

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 152

How does dynamic_cast work internally?

Answer 152

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 153

What is the difference between a deep copy and a shallow copy in C++?

Answer 153

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 154

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 154

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 155

Explain the memory layout of a C++ object.

Answer 155

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 156

How does dynamic_cast work internally?

Answer 156

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 157

What is the difference between a deep copy and a shallow copy in C++?

Answer 157

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 158

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 158

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 159

Explain the memory layout of a C++ object.

Answer 159

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 160

How does dynamic_cast work internally?

Answer 160

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 161

What is the difference between a deep copy and a shallow copy in C++?

Answer 161

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 162

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 162

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 163

Explain the memory layout of a C++ object.

Answer 163

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 164

How does dynamic_cast work internally?

Answer 164

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 165

What is the difference between a deep copy and a shallow copy in C++?

Answer 165

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 166

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 166

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 167

Explain the memory layout of a C++ object.

Answer 167

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 168

How does dynamic_cast work internally?

Answer 168

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 169

What is the difference between a deep copy and a shallow copy in C++?

Answer 169

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 170

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 170

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 171

Explain the memory layout of a C++ object.

Answer 171

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 172

How does dynamic_cast work internally?

Answer 172

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 173

What is the difference between a deep copy and a shallow copy in C++?

Answer 173

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 174

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 174

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 175

Explain the memory layout of a C++ object.

Answer 175

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 176

How does dynamic_cast work internally?

Answer 176

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 177

What is the difference between a deep copy and a shallow copy in C++?

Answer 177

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 178

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 178

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 179

Explain the memory layout of a C++ object.

Answer 179

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 180

How does dynamic_cast work internally?

Answer 180

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 181

What is the difference between a deep copy and a shallow copy in C++?

Answer 181

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 182

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 182

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 183

Explain the memory layout of a C++ object.

Answer 183

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 184

How does dynamic_cast work internally?

Answer 184

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 185

What is the difference between a deep copy and a shallow copy in C++?

Answer 185

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 186

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 186

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 187

Explain the memory layout of a C++ object.

Answer 187

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 188

How does dynamic_cast work internally?

Answer 188

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 189

What is the difference between a deep copy and a shallow copy in C++?

Answer 189

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 190

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 190

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 191

Explain the memory layout of a C++ object.

Answer 191

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 192

How does dynamic_cast work internally?

Answer 192

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 193

What is the difference between a deep copy and a shallow copy in C++?

Answer 193

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 194

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 194

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 195

Explain the memory layout of a C++ object.

Answer 195

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 196

How does dynamic_cast work internally?

Answer 196

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid

Question 197

What is the difference between a deep copy and a shallow copy in C++?

Answer 197

A:
- Shallow copy: Copies the memory addresses (pointers), leading to multiple objects pointing to the same memory location.
- Deep copy: Copies both the values and the memory locations, creating independent objects.

class MyClass {
    int* ptr;
public:
    MyClass(int val) {
        ptr = new int(val);
    }
    // Shallow Copy Constructor
    MyClass(const MyClass& obj) {
        ptr = obj.ptr;
    }
    // Deep Copy Constructor
    MyClass deepCopy(const MyClass& obj) {
        ptr = new int(*obj.ptr);
    }
};

Question 198

What are virtual tables (vtable) and virtual table pointers (vptr) in C++?

Answer 198

A:
- vtable: A table of function pointers that helps resolve dynamic method dispatch in classes with virtual functions.
- vptr: A hidden pointer in each object of a class that points to the class’s vtable.

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; }
};

The vptr is set at runtime to point to the vtable of the Base or Derived class depending on the type of the object.

Question 199

Explain the memory layout of a C++ object.

Answer 199

A:
A typical C++ object layout includes:
- Non-static data members: Stored directly in the object.
- vptr (if applicable): Points to the virtual table for dynamic dispatch.
- Padding: May be added for alignment.

class A {
    int x;   // 4 bytes
    char y;  // 1 byte
    // Padding of 3 bytes for alignment
};

Question 200

How does dynamic_cast work internally?

Answer 200

A:
dynamic_cast performs a runtime type check (RTTI). It uses the object’s vptr to determine its most derived type and checks if the cast is valid. If the cast is illegal, it returns nullptr for pointers or throws std::bad_cast for references.

class Base { virtual void func() {} };
class Derived : public Base {};
Base* base = new Derived();
Derived* derived = dynamic_cast(base); // Valid