Question 1

C++ object copying: which special member is used to make a copy of one object from another object of the same class type?

Accepted Answer

Introduction / Context: C++ defines special member functions to control copying, moving, construction, and destruction. When a new object must be initialized as a copy of an existing object, a particular special member is selected by the compiler. This question asks you to name that member precisely. Given Data / Assumptions: Two objects of the same class type are involved: a source and a destination. Initialization syntax such as T b = a; or T b(a); is used. No exotic conversion or template trickery; standard behavior is assumed. Concept / Approach: The copy constructor initializes a new object from an existing object. Its canonical signature is T(const T&). The ordinary constructor builds objects from scratch (possibly with parameters). The destructor tears objects down at end of lifetime. The “default constructor” is the zero-argument constructor and is unrelated to copying. Recognizing which special member applies to each situation is core C++ knowledge for managing resource ownership and value semantics correctly. Step-by-Step Solution: Identify scenario: initialization from another object of the same type. Recall rule: the copy constructor is chosen for copy-initialization and direct copy construction. Confirm signature: T(const T&) (with possible additional move constructor overloads in modern C++). Select “copy constructor.” Verification / Alternative check: Observe behavior when the copy constructor is deleted or private: the above forms of initialization become ill-formed, demonstrating the copy constructor’s role. Tools like compiler diagnostics explicitly mention “copy constructor is deleted.” Why Other Options Are Wrong: constructor: too general; does not specifically denote copying. destructor: runs at end-of-life, not at initialization. default constructor: creates objects without arguments, not from another object. Common Pitfalls: Confusing copy construction with copy assignment (operator=), which replaces the state of an already-initialized object. Neglecting to implement the rule of three/five/zero for resource-owning types. Final Answer: copy constructor

Question 2

C++ default constructor definition: what do we call a constructor that has no parameters, or whose parameters all have default values?

Accepted Answer

Introduction / Context: Default construction is ubiquitous in C++ because containers, arrays, and many APIs require the ability to create objects without supplying arguments. Understanding precisely what qualifies as a “default constructor” clarifies why certain code compiles—or fails—when zero-argument construction is attempted. Given Data / Assumptions: A class may have multiple constructors with or without parameters. If a constructor can be called with no arguments, it is considered a default constructor. Parameters with default values count as “optional.” Concept / Approach: A default constructor is any constructor that can be invoked with no arguments. This includes a function with an empty parameter list and also a constructor where every parameter has a default value, allowing calls with zero arguments. A copy constructor is distinct; it takes a reference to another object of the same type and initializes from it. Therefore, “default constructor” is the correct term for the described case, not “copy constructor” and not “both.” Step-by-Step Solution: Check whether the constructor can be called as T(). If yes (no parameters or all parameters defaulted), it is a default constructor. Copy constructors require a source object parameter and thus cannot be zero-argument. Therefore select “default constructor.” Verification / Alternative check: Declare T(int x = 1); and invoke T(). This compiles, demonstrating that defaulted parameters still yield a default constructor. Removing defaults and leaving only T(int) breaks zero-argument construction, illustrating the definition’s boundary. Why Other Options Are Wrong: Copy constructor: not callable with zero arguments. Both A and B: mixes distinct concepts. None of these: incorrect since a well-known term exists. Common Pitfalls: Assuming that declaring any constructor suppresses implicit default constructor generation entirely; rules depend on which constructors are declared. Confusing value-initialization and default-initialization details; both require an accessible default constructor. Final Answer: default constructor

Question 3

C++ constructors: which statement about return types and contents of constructors is correct?

Accepted Answer

Introduction / Context: Constructors are special member functions that initialize objects. Their syntax and type system rules differ from ordinary functions. This question checks whether you know the correct rule for a constructor’s return type and dispels common myths about what can appear inside a constructor’s body. Given Data / Assumptions: C++ constructors are named after the class. They participate in overload resolution during initialization. They may contain arbitrary statements, including function calls. Concept / Approach: A constructor has no return type—not even void. Attempting to specify a return type makes it an ordinary function, not a constructor, and compilation fails if you intend it to be a constructor. Inside the constructor body, you can certainly call other functions, initialize members in the member initializer list, and perform checks or throw exceptions if needed. Therefore, the correct statement is that a constructor has no return type. Step-by-Step Solution: Recall the form: ClassName(parameters) : member_inits { body } Note the absence of any return type before the name. Understand that function calls are allowed inside the body. Select “A constructor has no return type.” Verification / Alternative check: Try compiling int ClassName(); as a “constructor.” The compiler treats it as a normal function declaration, not a constructor, proving that constructors cannot declare a return type. Conversely, placing function calls in the body compiles and runs normally. Why Other Options Are Wrong: “Has a return type” or “has a void return type” contradict the language rule. “Cannot contain a function call” is false; constructors may call functions freely (and often do). Common Pitfalls: Confusing constructors with factory functions that return constructed objects. Performing heavy logic in constructors that could throw; consider noexcept guarantees or two-phase initialization where appropriate. Final Answer: A constructor has no return type.

Question 4

C++ constructors: which statement best describes overloading of constructors?

Accepted Answer

Introduction / Context: Overloading enables multiple functions with the same name but different parameter lists. Constructors are prime candidates for overloading because classes often need various ways to be initialized. This question asks whether constructor overloading is supported and appropriate in C++. Given Data / Assumptions: A single class may define several constructors. Each constructor must differ in parameter count and/or types. Modern C++ also includes copy and move constructors as overloads. Concept / Approach: Constructors can be overloaded. Common patterns include a default constructor, parameterized constructors for different argument sets, and the special copy and move constructors. Overloading permits flexible object creation strategies (e.g., from size, from iterator range, from string literal, etc.). The other options either misuse terminology (“nested”) or state false claims about prohibition of overloading or mere callability (which doesn’t address the question of overloading at all). Step-by-Step Solution: Identify requirement: multiple ways to initialize the same type. Provide distinct signatures: different counts/types of parameters. Rely on overload resolution to select the best match. Therefore, “can be overloaded” is correct. Verification / Alternative check: Implement several constructors and instantiate objects with different argument lists; compilation and correct overload selection confirm the feature. Adding two identical signatures results in a redefinition error, reinforcing the signature-difference rule. Why Other Options Are Wrong: cannot overloaded: contradicts core language capability. can be called: true but irrelevant to overloading. can be nested: not a meaningful statement in this context. Common Pitfalls: Overlapping overloads causing ambiguity; use delegating constructors or factory functions for clarity. Forgetting to maintain class invariants across all constructor overloads. Final Answer: can be overloaded

Question 5

C++ default constructors: how many default constructors can a single class have?

Accepted Answer

Introduction / Context: Although constructors may be overloaded, the notion of a “default constructor” is specific: it is a constructor callable with no arguments. This question explores how many such default constructors a class can define according to C++ rules and overload resolution constraints. Given Data / Assumptions: Multiple constructors may exist in a class. A default constructor is any constructor invocable with zero arguments. Signatures that can be called with no arguments are considered equivalent for default construction purposes. Concept / Approach: A class can have only one default constructor. You may have many constructors, but at most one of them can be viable with zero arguments. Having more than one would either be the same signature (redefinition error) or lead to ambiguity when invoked with no arguments. You can implement a single default constructor directly or by using default arguments to make one of the parameterized constructors callable with no arguments, but still there is only one effective default constructor in the set. Step-by-Step Solution: Define several constructors with distinct parameter lists. Ensure that no more than one can be called with zero arguments. Observe that attempting two zero-argument constructors is an ODR violation (redefinition). Conclude: a class can have only one default constructor. Verification / Alternative check: Try compiling a class with two constructors both invocable as T(). The compiler emits an error (duplicate definition or ambiguous call). Refactor so that exactly one is default-constructible, and the code compiles and runs. Why Other Options Are Wrong: Two/Three/Unlimited: contradict signature uniqueness and overload resolution rules. Common Pitfalls: Accidentally producing ambiguity by giving all parameters default values in more than one constructor. Assuming the compiler will choose one arbitrarily—ambiguity is a compile-time error. Final Answer: Only one

Question 6

In C++, when you allocate an array of objects using new[], how should you free that memory so that every element's destructor runs? Choose the correct form of the delete operator for arrays.

Accepted Answer

Introduction / Context: Managing dynamic memory safely in C++ requires using the correct deallocation form that matches the allocation form. When arrays of objects are involved, each element may hold resources that must be released via its destructor. This question focuses on the precise operator syntax that guarantees all destructors are invoked. Given Data / Assumptions: Memory is allocated with new[] for an array of objects, for example: T* p = new T[n]; Each element T might manage resources (files, heap memory, locks). We want every element's destructor to run exactly once. Concept / Approach: In C++, allocation and deallocation forms must match. If you allocate with new[], you must deallocate with delete[]. Using plain delete on memory obtained via new[] yields undefined behavior and typically destroys only the first element, skipping the rest. The pairings are: new ↔ delete, and new[] ↔ delete[]. Step-by-Step Solution: 1) Allocate: T* p = new T[n];2) Use the array p[0] ... p[n-1] as needed.3) Deallocate correctly: delete[] p; // invokes ~T() for each element, then frees memory4) Avoid: delete p; // incorrect for arrays; may leak resources and causes undefined behavior Verification / Alternative check: Instrument ~T() to log. With delete[] p, logs appear n times in reverse order of construction. With incorrect delete p, only one log may appear, confirming the mismatch problem. Why Other Options Are Wrong: destructor: not an operator; you do not call destructors on arrays manually.kill[] / free[]: not C++ operators; free is a C function for malloc-based memory, not new[].delete: correct only for single-object allocations done with new, not arrays. Common Pitfalls: Mixing allocation APIs (new/new[] with malloc/free) and forgetting to use delete[] for arrays. Prefer smart pointers or standard containers (std::vector) to avoid manual memory management. Final Answer: delete[]

Question 7

In C++ object lifetime management, which special member function is automatically executed when an object goes out of scope or is deleted?

Accepted Answer

Introduction / Context: C++ guarantees deterministic cleanup for objects through a special member function that runs at the end of an object's lifetime. Understanding which function this is underpins Resource Acquisition Is Initialization (RAII) and exception safety. Given Data / Assumptions: An automatic (stack) object leaves scope. A dynamically allocated object is deleted via delete or delete[]. We assume normal termination and stack unwinding. Concept / Approach: The destructor (~ClassName) executes when the object's lifetime ends. It should release any resources acquired by the object, such as memory, file handles, sockets, or locks. Constructors initialize; destructors finalize. Virtual destructors enable correct cleanup via base-class pointers in polymorphic hierarchies. Step-by-Step Solution: 1) Create object: Widget w; → constructor runs.2) Scope ends or delete p; is called → destructor ~Widget() runs.3) Inside ~Widget(), free resources and maintain invariants.4) Program proceeds with resources properly released. Verification / Alternative check: Add logging to ~Widget(). You will observe a call each time an object is destroyed, including in reverse order for multiple objects in the same scope. Why Other Options Are Wrong: constructor: runs at creation time, not destruction.virtual function: generic term; destructors themselves can be virtual.main: program entry point, unrelated to object teardown.assignment operator: handles assignment between existing objects, not end-of-life. Common Pitfalls: Forgetting to declare a virtual destructor in a polymorphic base class and deleting derived objects via a base pointer, which leaks resources or produces undefined behavior. Final Answer: destructor

Question 8

In standard C++, which of the following entities cannot be declared as virtual? Select the most accurate combination.

Accepted Answer

Introduction / Context: Virtual dispatch enables runtime polymorphism by selecting the most-derived override of a function. However, not every class element can be declared virtual. This question checks which entities are excluded by the language rules. Given Data / Assumptions: C++ supports virtual non-static member functions. Polymorphic destruction requires virtual destructors in base classes used polymorphically. We consider constructors and data members. Concept / Approach: Constructors cannot be virtual because object type is known during construction and the vtable is not yet fully established for dispatch to an as-yet-unconstructed most-derived object. Data members cannot be virtual because they are not functions and do not participate in dynamic dispatch. Destructors, on the other hand, can and often should be virtual in polymorphic bases to ensure correct cleanup through base pointers. Step-by-Step Solution: 1) Examine constructors: virtual keyword is disallowed → not virtual.2) Examine data members: only functions are virtual; data cannot be → not virtual.3) Examine destructors: may be declared virtual and are commonly used that way.4) Therefore, the correct combined answer is “Both A and C”. Verification / Alternative check: Attempt to compile a class with a virtual data member or a virtual constructor; compilers reject these constructs. A virtual destructor compiles and dispatches properly via base pointers. Why Other Options Are Wrong: Constructor alone or data member alone: incomplete; both are non-virtual by rule.Destructor: can be virtual; marking this as “cannot” is incorrect.Member functions (other than constructors): these can be virtual. Common Pitfalls: Confusing virtual constructors with factory patterns; factories simulate construction polymorphism without requiring a virtual constructor keyword. Final Answer: Both A and C

Question 9

Which of the following is NOT automatically provided by a C++ compiler when you do not define any of them yourself?

Accepted Answer

Introduction / Context: C++ compilers may implicitly declare or define certain special member functions when the programmer does not supply them. Knowing which are real and which are mythical helps avoid confusion. This question asks you to identify a non-existent concept among common terms. Given Data / Assumptions: No user-declared constructors, destructors, or copy/move operations are present. We consider classical and modern C++ behavior. “Copy destructor” is presented as an option. Concept / Approach: The compiler can implicitly provide: a default (zero-argument) constructor, a destructor, a copy constructor, a copy assignment operator, and, in modern C++, move operations when conditions permit. There is no such thing as a “copy destructor.” A destructor has a fixed signature and cannot be “copied.” Step-by-Step Solution: 1) List real special members: default ctor, dtor, copy ctor, copy assignment, and possibly move ctor/assignment.2) Identify the imposter: “Copy Destructor”.3) Conclude that the only option not provided (indeed, not a thing) is the copy destructor.4) Select “Copy Destructor”. Verification / Alternative check: Check any C++ reference: the catalog of special member functions never includes a copy destructor. Why Other Options Are Wrong: Default constructor / destructor / copy constructor: all may be implicitly generated by the compiler.Move constructor: in eligible situations, modern compilers can generate it too; it still exists as a concept. Common Pitfalls: Assuming the default constructor is always generated; it is suppressed if you declare any constructor. Also, implicit generation may be deleted depending on member types. Final Answer: Copy Destructor

Question 10

In C++, a class's destructor has the same base name as the constructor but is prefixed by which symbol? Select the correct leading character used in the destructor's syntax.

Accepted Answer

Introduction / Context: Destructor syntax is intentionally simple and uniform across classes so programmers can quickly recognize cleanup code. The destructor name is derived from the class name using a specific prefix character. Given Data / Assumptions: Class name is, for example, Widget. We want the exact symbol that denotes a destructor. Syntactic correctness matters for compilation. Concept / Approach: The destructor is written as ~ClassName(). For a class Widget, the destructor is ~Widget(). No return type or parameters are allowed. The leading character is the tilde symbol, not any other punctuation character. Step-by-Step Solution: 1) Recall: constructor → Widget(); destructor → ~Widget().2) Note there is no return type and no parameters for the destructor.3) Identify the prefix character: ~ (tilde).4) Select the correct option accordingly. Verification / Alternative check: Compile a class with ~ClassName(); omitting the tilde or using other symbols leads to errors. Why Other Options Are Wrong: ! ? $ #: not part of destructor syntax; using them will not compile. Common Pitfalls: Attempting to add a return type to ~ClassName or parameters; both are illegal in C++. Final Answer: ~

Question 11

If a C++ programmer does not explicitly define a destructor for a class, who provides an empty destructor automatically?

Accepted Answer

Introduction / Context: C++ defines a set of special member functions that may be implicitly declared or defined by the compiler to ensure sane object semantics. One of these is the destructor, responsible for cleanup when an object's lifetime ends. This question asks which component supplies a default destructor when you do not write one. Given Data / Assumptions: No user-declared destructor exists in the class. The build process includes preprocessing, compiling, linking, and loading. We focus on who generates the destructor code. Concept / Approach: The C++ compiler implicitly declares and may define a destructor if none is provided. The preprocessor only performs textual substitution; the linker combines object files; main() is just the entry point; the runtime loader maps binaries into memory. None of those create class members. Therefore, the correct answer is the compiler. Step-by-Step Solution: 1) Omit ~ClassName() in your class.2) The compiler synthesizes a default destructor with empty body semantics appropriate for the class.3) This synthesized destructor destroys members and bases automatically via their destructors.4) Program compiles and links without you writing explicit cleanup code. Verification / Alternative check: Compile a trivial class without a destructor; observe that objects can be created and destroyed, and member destructors are invoked automatically. Why Other Options Are Wrong: Preprocessor: macro substitution only.Linker/loader/main: do not generate C++ class members. Common Pitfalls: Assuming an implicit destructor is noexcept; check exception specifications as needed. Often, user-defined destructors should be marked noexcept to support strong guarantees. Final Answer: Compiler

Question 12

In C++, when are global (namespace-scope, static-duration) objects destroyed?

Accepted Answer

Introduction / Context: Objects in C++ have lifetimes determined by their storage duration. Global objects (including namespace-scope statics) have static storage duration, meaning they exist for the entire run of the program. This question targets their destruction moment. Given Data / Assumptions: Objects are defined at namespace scope or as static-duration items. Program startup initializes these objects before main begins (in a well-defined order per translation unit rules). We examine when their destructors run. Concept / Approach: Static-duration objects are constructed before main() begins (after dynamic initialization) and are destroyed during program termination, after main() returns or std::exit is called, in the reverse order of construction within a translation unit. Destruction order across translation units follows implementation-defined rules but still occurs at program shutdown. Step-by-Step Solution: 1) Identify an object with static storage: global T g; or static T s;2) Program starts → dynamic initialization occurs → objects become live.3) Program terminates normally → destructors for these objects are invoked.4) Order is reverse of construction for the same translation unit. Verification / Alternative check: Instrument constructors and destructors of global objects; you will observe construction before main() and destruction after main() ends. Why Other Options Are Wrong: Block/function exit: those apply to automatic storage, not static-duration objects.“As soon as local objects die” or “immediately after main() starts”: contradict static lifetime semantics. Common Pitfalls: Relying on a specific cross-translation-unit destruction order; use the “construct on first use” idiom or dependency-breaking techniques where order matters. Final Answer: When the program terminates.

Question 13

Which statement correctly describes constructor and destructor naming rules in C++?

Accepted Answer

Introduction / Context: Constructors and destructors are special member functions tightly bound to a class's identity. Their names follow strict syntactic rules so the compiler can recognize them and apply lifetime semantics. This question asks which statements about those names are correct. Given Data / Assumptions: A class is named, e.g., Gadget. Constructors and destructors are declared within the class. We compare naming forms. Concept / Approach: A constructor's name exactly matches the class name (Gadget::Gadget). A destructor's name matches the class name prefixed by a tilde (Gadget::~Gadget). This uniform naming enables the compiler to apply special rules: no return type, constructor overloading, and implicit invocation on creation/destruction. Step-by-Step Solution: 1) For class Gadget, constructor is Gadget().2) Destructor is ~Gadget().3) Both statements together accurately describe the naming scheme.4) Therefore, choose “Both A and B.” Verification / Alternative check: Try compiling a class with differently named constructor or destructor; the compiler will not treat them as special members. Why Other Options Are Wrong: Naming a destructor after the first member function is meaningless.Constructors do not begin with a tilde; only destructors do. Common Pitfalls: Accidentally giving a return type to constructors/destructors or misspelling the class name, which turns them into ordinary functions and breaks object lifetime semantics. Final Answer: Both A and B.

Question 14

When you do not explicitly declare any constructors for a C++ class, which translation stage will implicitly declare a default (zero-argument) constructor if eligible?

Accepted Answer

Introduction / Context: C++ supports implicitly-declared special member functions to simplify class usage. One is the default constructor, which enables default-initialization of objects when no user-declared constructors exist. This question asks which stage is responsible for creating it. Given Data / Assumptions: No constructors are declared by the programmer. We consider standard compilation pipeline roles. Eligibility rules for implicit declaration are satisfied. Concept / Approach: The compiler analyzes class definitions and, if the rules allow, implicitly declares a default constructor. The preprocessor only handles macros and includes; the linker and loader deal with binary combination and loading; neither invents C++ class members. Hence, the compiler is the correct answer. Step-by-Step Solution: 1) Write class C {}; with no constructors.2) The compiler implicitly declares C::C().3) You can then write C c; and it compiles.4) If you declare any constructor, the implicit default constructor is no longer provided automatically unless you write C() = default;. Verification / Alternative check: Inspect error messages when adding a parameterized constructor but forgetting to add a default one; the compiler will note that C is not default-constructible. Why Other Options Are Wrong: Preprocessor/linker/loader: not responsible for generating C++ class members.Run-time library: does not declare constructors. Common Pitfalls: Assuming a default constructor will still exist after declaring other constructors; explicitly declare or default it if you need default construction. Final Answer: Compiler

Question 15

Which of the following in C++ never requires any arguments by definition? Choose the construct that can always be invoked with zero parameters.

Accepted Answer

Introduction / Context: Some functions in C++ may be invoked with or without arguments depending on their signatures. A specific kind of constructor, however, is defined by its ability to be called with no arguments at all. This question targets that definition. Given Data / Assumptions: We use the standard definition from the C++ language. Other function categories (member/friend/operator) depend on how they are declared. We are not assuming variadic or defaulted parameters except where the definition requires zero arguments. Concept / Approach: A default constructor is any constructor that can be called without arguments. It typically has no parameters, or all parameters have default values so that a call with zero arguments is valid. In contrast, ordinary member functions, friend functions, or overloaded operators may or may not require arguments depending on their signatures; they are not guaranteed to be argument-free. Step-by-Step Solution: 1) Consider struct T { T(); }; → T() is callable with zero arguments.2) Consider struct U { U(int x = 0); }; → still callable as U() because x has a default value.3) Member/friend/operator functions require arguments only if declared that way; not universal.4) Therefore, the only construct that never requires arguments by definition is the default constructor. Verification / Alternative check: Attempt to instantiate a class with a default constructor using T t; It compiles without providing arguments, satisfying the definition. Why Other Options Are Wrong: Member/friend/overloaded operator: may or may not take parameters; no guarantee of zero-argument invocation.const function: “const” qualifies the implicit object parameter of a member function; it does not dictate argument count. Common Pitfalls: Equating “no-parameter constructor” with “compiler-provided in all cases.” If any constructor is declared, the default constructor is not implicitly provided unless explicitly defaulted. Final Answer: Default constructor

Question 16

C++ object lifetime: how many times is a constructor invoked during the entire lifetime of a single object? Choose the most accurate statement.

Accepted Answer

Introduction / Context: Constructors in C++ are special member functions that initialize an object into a valid state. Understanding exactly how many times a constructor is called per object helps clarify object lifetime, copy/move semantics, and where initialization truly happens versus later mutations. Given Data / Assumptions: We are talking about a single, concrete object instance. Object creation may be automatic (block scope), dynamic (using new), static, or temporary. Copy and move constructors count as constructors too, but each applies only when a new object is created. Concept / Approach: A constructor (of some form) is called exactly once for each object: at its creation. After the object exists, later assignments or method calls do not “reconstruct” it; they simply modify state. If an object is created via copy or move, the corresponding copy/move constructor is the one invoked, still exactly once for that object. Reassignment later invokes assignment operators, not constructors. Step-by-Step Solution: For an automatic object T x; → one constructor call at definition. For a dynamically allocated object new T(...) → one constructor call at allocation site. For a copy T y = x; → one copy constructor call for y (still once per y). For a temporary T() → one constructor call for that temporary instance. Verification / Alternative check: Add logging to all constructors and operators. You will observe exactly one constructor log per created object, matched by at most one destructor log at end-of-life (if not elided). Copy elision can remove extra temporary constructions, but each ultimately created object is still constructed once. Why Other Options Are Wrong: Twice/Thrice: there is no scenario where a single object is “constructed” multiple times. Depends on the way of creation: the specific constructor overload may differ, but the count per object remains one. Common Pitfalls: Confusing copy assignment with copy construction; only the latter creates a new object. Misreading logs when copy elision/moves are at play. Final Answer: Only once

Question 17

C++ object scope: when an object goes out of scope, which special member function is invoked automatically?

Accepted Answer

Introduction / Context: C++ relies on deterministic destruction (RAII) to release resources such as memory, files, sockets, and locks. Understanding which function runs at scope exit is essential for writing safe code that cleans up reliably, even when exceptions occur. Given Data / Assumptions: An automatic (stack) object leaves scope due to normal flow, return, or exception. No custom “parameterized” destructors exist in C++; destructors take no parameters. We focus on the automatic invocation that happens at scope exit. Concept / Approach: When an object’s lifetime ends (e.g., the block closes), C++ automatically calls its destructor. There is no such thing as a parameterized destructor; the language grammar forbids parameters. The constructor runs at object creation, not at destruction. Therefore, the correct choice is that the object’s (default) destructor is called at scope exit, ensuring cleanup of the object and its subobjects in reverse order of construction. Step-by-Step Solution: Define an object inside a block → constructor runs at definition. Exit the block → destructor runs automatically. Members and bases are destroyed automatically in reverse order. Any owned resources are released in the destructor body. Verification / Alternative check: Instrument the destructor to log a message. You will see it triggered at scope exit or on delete for dynamically allocated objects; constructors never run at scope exit. Why Other Options Are Wrong: Default constructor at scope exit: constructors initialize, not finalize. Parameterized destructor: invalid concept in C++. None of the above: wrong because the destructor is indeed called. Common Pitfalls: Forgetting virtual destructors in polymorphic bases, causing leaks via base pointers. Assuming garbage collection semantics; C++ uses deterministic destruction. Final Answer: The default destructor of the object is called.

Question 18

C++ object creation: which special member function is invoked when an object is being created?

Accepted Answer

Introduction / Context: Object construction is the first step in an object’s lifetime. C++ provides a family of constructors (default, parameterized, copy, move) to set up invariants and acquire resources. Identifying which mechanism runs at creation is foundational to RAII and exception safety patterns. Given Data / Assumptions: The object is being defined or dynamically allocated. No prior state exists for the object; storage is uninitialized until construction. We distinguish constructors from destructors and ordinary virtual functions. Concept / Approach: At creation, C++ calls a suitable constructor based on the provided arguments (or none). The constructor establishes class invariants and initializes members (often via the member-initializer list). Virtual functions participate in runtime dispatch after construction; they are not “called to create” an object. Destructors run at the end of the lifetime, not the beginning. The global function main is the program entry point and unrelated to individual object creation. Step-by-Step Solution: Automatic object T x; → select default or matching parameterized constructor. Dynamic object new T(args) → allocate storage then call chosen constructor. Copy construction T y = x; → invoke copy constructor for y. Move construction T z = std::move(x); → invoke move constructor for z. Verification / Alternative check: Insert logging into each constructor. Logs appear exactly at creation time, confirming the role of constructors. Virtual calls during construction dispatch to the most-derived subobject constructed so far; they do not “create” the object. Why Other Options Are Wrong: Virtual function: ordinary member with dynamic dispatch, not used to create objects. Destructor: used at destruction, not creation. main: unrelated to per-object initialization. Common Pitfalls: Calling virtuals from constructors expecting full dynamic dispatch (the most-derived part may not yet be constructed). Final Answer: constructor

Question 19

C++ constructors: which constructor is specifically designed to copy one object from another object of the same class type?

Accepted Answer

Introduction / Context: Copying semantics determine how values propagate and how resources are duplicated or shared. C++ recognizes a special member function that initializes a new object from an existing one of the same type. Knowing its name and role helps you reason about value semantics and ownership policies (rule of three/five/zero). Given Data / Assumptions: We are creating a new object from an existing object. Syntax examples: T b = a; or T b(a); We are not assigning to an already-initialized object (that would be copy assignment). Concept / Approach: The copy constructor has the conventional signature T(const T&). It runs when a new object is constructed from another, including function parameter passing by value and function return by value (subject to elision/moves). A “dynamic constructor” is a colloquial phrase sometimes used for constructors that allocate resources; it is not a standard term. “Create constructor” and “Object constructor” are not C++ terms of art. Step-by-Step Solution: Recognize the operation: new object from existing object → copy construction. Select the special member that implements it: copy constructor. Confirm alternative cases: copy assignment applies only to already-existing objects. Therefore choose “Copy constructor.” Verification / Alternative check: Delete or make private the copy constructor and observe that copy-initialization fails, proving it is the mechanism used by the compiler for such constructions. Implementing a move constructor changes behavior for rvalues but not lvalue copies. Why Other Options Are Wrong: Create/Object constructor: non-standard labels. Dynamic constructor: vague; not the standardized name for copying. Common Pitfalls: Confusing copy construction with copy assignment. Neglecting deep-copy needs for owning pointers; prefer smart pointers or rule-of-zero designs. Final Answer: Copy constructor

Question 20

C++ base-class constructor vs member-object constructor: trace printed members.  #include <iostream.h> class CuriousTabBase { public:  int x, y;  CuriousTabBase(int xx = 0, int yy = 0) { x = xx; y = yy; } }; class CuriousTabDerived : public CuriousT…

Accepted Answer

Introduction / Context: The problem probes constructor initializer lists for a derived class and a contained member object. It checks whether you can follow which values are passed to the base subobject versus the member subobject and how defaulted parameters are used. Given Data / Assumptions: CuriousTabBase(xx = 0, yy = 0) stores x = xx, y = yy. CuriousTabDerived(int xx, int yy) : CuriousTabBase(xx), objBase(yy). Prints: this->x, this->y, objBase.x, objBase.y. Concept / Approach: The base subobject of CuriousTabDerived receives only xx, so xx maps to x and the default yy = 0 sets base y to 0. The member object objBase(yy) receives yy as its first argument (xx), while its own second parameter defaults to 0. So objBase.x = yy and objBase.y = 0. Step-by-Step Solution: Construct base: CuriousTabBase(xx) → x = 11, y = 0.Construct member: objBase(yy) with yy = 22 → objBase.x = 22, objBase.y = 0.cout prints: 11 0 22 0. Verification / Alternative check: If the base initializer were CuriousTabBase(xx, yy) then this->y would be 22; if objBase were constructed as objBase(yy, yy) then objBase.y would be 22. Neither is done here. Why Other Options Are Wrong: 11 22 0 0: assigns yy to base y, which does not happen. 11 0 0 22: swaps x/y mapping for objBase. 11 22 11 22: would require passing both parameters to both ctors. Compile error: none present. Common Pitfalls: Forgetting that default parameters fill omitted ctor args; confusing base-subobject initialization with member-object initialization. Final Answer: 11 0 22 0

Constructors and Destructors Questions