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 ```