CS304 Object Oriented Programming Midterm MCQs

The data portion of an object encompasses the properties and values that define its current state.

Inheritance allows you to create new classes (derived classes) that inherit properties and behaviors from existing classes (base classes) without rewriting them. This helps in code reuse and organization.

The Patient class would inherit from the Person class and add attributes specific to patients, such as diagnosis, registration date, and perhaps spouse information. Inheriting from Person avoids duplicating 'name', 'age', and 'sex' attributes.

Copying objects without a deep copy constructor can lead to dangling pointers (pointing to freed memory) and memory leaks. Deep copy constructors ensure that all data members are duplicated, avoiding shared memory and potential issues when original objects are modified.

The 'this' pointer is unavailable inside static member functions because static functions belong to the class itself, not to individual objects. Since 'this' refers to the current object, it doesn't apply to static functions.

Static member functions are associated with a class rather than individual objects. They lack the 'this' pointer and can be invoked directly using the class name without creating an object.

Static variables are declared within a class but belong to the class itself, not individual objects. Their values persist even when all class objects are destroyed, acting as a shared memory space for all instances of that class.

Friend functions are defined outside a class but have access to its private and protected members. They are not member functions of the class but are granted special privileges by the class itself.

Friendship relationship is one-way. Class A declaring B as its friend doesn't mean A can access B's private data. Instead, B can access all of A's data.

The statement "objA = objB" will cause a compiler error if objA and objB belong to different classes because they have different data structures. A direct assignment is not allowed between objects of incompatible types.

The correct declaration for overloading the + operator to add a double value to a Rational_number object is: Rational_number operator+(double& obj); This allows the compiler to automatically perform the conversion when a Rational_number object is added to a double value.

The conditional operator (? :) cannot be overloaded in C++ because its behavior is fixed by the language and cannot be modified by user-defined operators.

To convert from a user-defined class to a basic type, you would use a conversion operator declared as a member of the class. This operator allows you to explicitly or implicitly convert an object of that class into the desired basic type.

Object-oriented programming (OOP) encourages modeling programming problems based on real-world objects and their relationships. This approach focuses on entities, their attributes (data), and their actions (behavior).

In OOP, a class can inherit properties from another class through inheritance. This allows you to create specialized classes (derived classes) that extend the functionality of existing classes (base classes).

A C++ class is similar to a structure in that both define a blueprint for data and functions. However, classes offer more features like data hiding, inheritance, and polymorphism, making them more versatile and powerful.

Copying objects without a deep copy constructor can cause dangling pointers, memory leaks, and potentially system crashes because the copied object shares the same memory as the original. This can lead to unexpected behavior if one object is modified.

If a class does not have an overloaded assignment operator, the automatic assignment operator provided by the language is used. This typically performs a shallow copy, which copies references, potentially leading to the shared memory issues mentioned earlier.

A static member function can be called without instantiating an object of the class, because it is associated with the class itself rather than a specific object. This is similar to using static methods in other languages.

The correct overload declaration for adding a double value to a Rational_number object is: Rational_number operator+(double& obj); This allows the compiler to convert the double value to a Rational_number automatically.

Accessor functions, also known as getter functions, provide controlled access to private data members, ensuring data integrity and encapsulation. They provide a safe way to retrieve the values of private attributes.

A constant object's state cannot be modified after its initialization. This enforces immutability, preventing accidental changes to the object's data.

The 'has-a' relationship in OOP indicates that one object contains another object as a member, representing a whole-part association.

Inheritance allows a new class to inherit properties and behaviors from an existing class, implementing a generalization-specialization relationship. This builds upon existing functionality and promotes code reuse.

Inheritance is a relationship in OOP where a derived class inherits properties from a base class. This allows for code reuse and the creation of specialized classes based on existing ones.

Polymorphism allows an object to take on multiple forms. This enables the same function call to behave differently depending on the actual type of the object at runtime.

Inheritance is used to implement a generalization-specialization relationship between classes. It allows a derived class to inherit properties and behaviors from a base class, forming a hierarchical structure.

The >= operator can be overloaded in C++ to define a custom behavior for comparison between objects of user-defined classes. This allows you to define how objects of your class compare to each other.

The destructor of a class is called automatically when an object of that class goes out of scope or is explicitly deleted using the 'delete' operator. This ensures the object's resources are properly cleaned up.

Multiple inheritance allows a class to inherit from multiple base classes, inheriting attributes and behaviors from each. This can be useful for modeling complex relationships with multiple parent classes.

Static variables are initialized only once, when the class is loaded. Subsequent initialization attempts are ignored.

Abstraction in OOP aims to create a generic representation of a concept by hiding unnecessary details, focusing only on the essential properties and behaviors. This allows for code reuse and creates a simplified view of complex entities.

Static variables are declared within a class but belong to the class itself, not individual objects. Their values persist for all objects of that class, allowing for shared data across instances.

The compiler doesn't check the correctness of the overloaded operator's implementation. You can, for example, overload the * operator to perform division, but this could lead to unintended consequences and confusion.

While the 'this' pointer is generally available within constructors, it's generally considered best practice to avoid using it directly in the constructor body or initialization list to prevent potential confusion and errors with the 'this' pointer related to uninitialized data members.

A C++ class is similar to a structure in that both define a blueprint for data and functions. However, classes offer more features like data hiding, inheritance, and polymorphism, making them more versatile and powerful.

The conditional operator (? :) cannot be overloaded in C++ because its behavior is fixed by the language and cannot be modified by user-defined operators.

An overloaded operator always takes one less argument than the number of operands it represents. For example, an overloaded binary operator (like + or *) takes one argument, but represents two operands.

Inheritance is used to implement a generalization-specialization relationship between classes. It allows a derived class to inherit properties and behaviors from a base class, forming a hierarchical structure.

A class is a user-defined data type that represents a blueprint for objects. It defines the attributes (data members) and behaviors (member functions) that objects of that class will have.

Classes are typically named using nouns, reflecting the real-world entity they represent. This helps in understanding the purpose and role of the class within your program.

Public members of a class are accessible directly from outside the class, through object instances or using the scope resolution operator. They provide the interface for interacting with the object from other parts of your code.

An object's attributes are its properties or characteristics, representing the specific data that defines its state. By understanding these attributes, we can capture the essential features of an object.

A derived class can add new data members, member functions (including friend functions), constructors, and destructors, enhancing its functionality and specializing its behavior. It builds upon the base class's capabilities.

Public member functions, which are part of a class's interface, provide controlled access to private data members, ensuring data integrity and encapsulation. They act as the gateway for interaction with the object's internal state.

The 'this' pointer is unavailable inside static member functions because static functions belong to the class itself, not to individual objects. Since 'this' refers to the current object, it doesn't apply to static functions.

Static member functions are associated with a class rather than individual objects. They lack the 'this' pointer and can be invoked directly using the class name without creating an object.

In C++, objects can be dynamically allocated using the 'new' operator, allowing for flexible memory management and the creation of objects at runtime.

To improve the 'Base' class with respect to accessing the 'Age' field, it's highly recommended to make 'Age' private and define getter and setter methods (get_age() and set_age()) to provide controlled access. This ensures data encapsulation and proper modification.

Both friend classes and friend functions can provide alternative ways to access the private members of a class. However, they serve different purposes and often have distinct advantages depending on the specific situation.

When overloading the increment (++), decrement (--), or dereference (*) operators, they usually do not take explicit arguments. The arguments are implicitly provided by the context of the operator.

If a class does not have an overloaded assignment operator, the default assignment operator, provided by the language, is used. This typically performs a shallow copy, which copies references, potentially leading to shared memory issues.

For the expression "obj3 = obj1 - obj2" to work, the overloaded '-' operator must return a value. This value is used to assign the result to the 'obj3' object, completing the operation.

The conditional operator (? :) cannot be overloaded in C++ because its behavior is fixed by the language and cannot be modified by user-defined operators.

Abstraction allows us to focus on the essential aspects of a concept rather than its detailed implementation. This promotes code reuse and simplifies the interface for other parts of the program.

Inheritance is a specialized form of object association, representing a 'is-a' relationship. Other forms include simple association (objects can interact without a parent-child relationship), aggregation (a 'has-a' relationship where parts can exist independently), and composition (parts cannot exist without the whole).

A class encapsulates the attributes (data members) and behaviors (member functions) of a real-world object within a single unit, defining its characteristics and actions.

Constructors do not have an explicit return type. They are implicitly understood to construct objects and their return type is determined by the type of object they create.