Object-Oriented Programming

In C++ terminology, a function contained within a class is called a 'Member Function'. Member functions are functions that are defined inside a class definition and operate on the class's data members. They're also commonly referred to as 'methods', but the formal C++ term is 'member function'. 'Private Function' describes an access level, not the function type itself. 'Method Function' is redundant terminology, and 'Class' refers to the containing structure, not the function.

Operator overloading in C++ serves two purposes: it gives new meaning to existing C++ operators (like redefining what '+' does for custom objects) AND it makes C++ operators work with user-defined objects (enabling expressions like obj1 + obj2). Option A captures the definitional aspect, while option B captures the functional capability. Therefore, operator overloading encompasses both - it's both giving new meanings to operators and enabling them to work with objects beyond primitive types.

Function overloading in C++ allows multiple functions to share the same name within the same scope. The key requirement is that they must have different parameter lists - either different numbers of parameters or different types. Option A correctly captures this: it's 'a group of functions with the same name' (implying the group as a whole shares one name while individual functions are distinguished by parameters). Options B and C are incorrect because overloaded functions must NOT have the same number and type of arguments - that would be a redefinition error, not overloading.

The Singleton pattern specifically restricts a class to a single instance. Option D is correct - Singleton ensures only one instance exists and provides global access. Options A, B, and C are incorrect because Command, Limiter (not a standard GoF pattern), and Strategy don't limit instance count - they're behavioral patterns focused on execution, encapsulation, and algorithm variation respectively.

Iterators provide a way to access elements of a collection sequentially without exposing its underlying representation. They are specifically designed for collection classes where you need to traverse elements uniformly regardless of the collection's internal structure.

Factory Method is known as Virtual Constructor because it defers object instantiation to subclasses, allowing the client code to work with product interfaces without knowing the concrete classes being instantiated. Abstract Factory creates families of related objects, not individual instances via virtual construction.

Decorator is known as Wrapper because it wraps an object to add new behavior dynamically without altering its structure, stacking multiple decorators for combined effects. Adapter also wraps but for interface compatibility, not behavior extension.

Testing object-oriented class operations is complicated by inheritance and polymorphism. Inheritance creates complex relationships where a test for a parent class may need to cover child classes. Polymorphism means the same operation can behave differently depending on object type, requiring more comprehensive test coverage.

Value types are implicitly sealed because they cannot be inherited from - they're either primitives or structs. This is a fundamental characteristic of value types in the CLR type system, not an explicit modifier you apply. The other modifiers (Static, InitOnly, Virtual, Abstract) are member modifiers, not type-level modifiers.

The class my_class contains two int data members (x and y). Given that int occupies 2 bytes, the total size is 2 + 2 = 4 bytes. Member functions (add, display) do not contribute to object size as they are stored once in the code segment, not per object instance. Options B, C, and D incorrectly add extra bytes for member functions or padding.

An abstract class in C++ is a class that contains at least one pure virtual function and cannot be instantiated directly - meaning you cannot create objects of the abstract class type itself. However, you CAN create pointers/references to it, and you MUST derive from it to create objects of the derived classes. Option A is incorrect because abstract classes are designed to be inherited. Option D is wrong because abstract classes can inherit from other classes.

Dynamic binding (also called runtime polymorphism) in C++ is achieved through virtual functions. When a function is declared virtual, the compiler creates a vtable (virtual table) for the class, and function calls are resolved at runtime based on the actual object type rather than the pointer/reference type. Method overloading and operator overloading are compile-time polymorphism (static binding), not dynamic.

Constructors CANNOT be virtual because they initialize objects and virtual dispatch mechanisms (vtables) aren't available until after construction completes. Destructors CAN and SHOULD be virtual when a class is designed for polymorphism to ensure proper cleanup of derived class resources. Constructors CAN be overloaded (multiple constructors with different parameters). Virtual functions have slight performance overhead due to vtable lookup, so they're slower than direct function calls.

Constructors run automatically every time a new object of that class type is instantiated. In C++, destructors run when each individual object goes out of scope, not merely at the end of the entire program, and constructors can accept parameters.

A copy constructor in C++ takes a reference to an object of the same class. Declaration (3) 'C(C& t);' is the correct form - it accepts a reference to a C object. Declaration (2) 'C(C t);' creates a copy constructor that takes by value, which would cause infinite recursion (copying the argument requires calling the copy constructor), but C++ treats this as a valid declaration despite being problematic. The standard form is (3), and (2) is technically a copy constructor declaration though ill-formed.