Object Oriented Programming in C++ Exam - MCADD-501

Object-oriented programming (OOP) features include encapsulation, inheritance, and polymorphism. Encapsulation bundles data and methods into a single unit. Inheritance allows classes to inherit properties from parent classes. Polymorphism enables objects to have different behaviors based on their type. OOP emphasizes data hiding and modularity, promoting code reusability and maintainability. In contrast, procedure-oriented programming focuses on procedures and functions, with data treated independently.

C++ offers various loop types for iterative tasks. The "for" loop is used when the number of iterations is known beforehand. Example: for (int i = 0; i < 5; i++) { cout << i << endl; } This loop iterates five times and prints values 0 to 4. The "while" loop executes as long as a condition is true. Example: while (x < 10) { x++; } This loop increments variable "x" until it reaches 10. The "do-while" loop executes at least once, then checks the condition for subsequent iterations. Example: do { // code to be executed } while (y > 0); This loop will always execute once, then check the condition "y > 0" to continue iterating.

#include <iostream>
using namespace std;
class Complex {
private:
double real, imag;
public:
Complex(double r = 0, double i = 0) {
real = r;
imag = i;
}
Complex operator+(const Complex& obj) {
Complex temp;
temp.real = real + obj.real;
temp.imag = imag + obj.imag;
return temp;
}
void display() {
cout << real << " + " << imag << "i" << endl;
}
};
int main() {
Complex c1(10, 5), c2(2, 4), c3;
c3 = c1 + c2;
c1.display();
c2.display();
c3.display();
return 0;
}

<p>Dynamic initialization refers to initializing objects during runtime, using constructors. This enables object creation and assignment of values at the time of execution. It proves beneficial for situations where the size or contents of an object are determined at runtime, making it more flexible and adaptable to changing conditions. For example, you can dynamically allocate memory based on user input or other runtime information, avoiding potential memory waste or limitations imposed by static allocation.</p> Signup and view all the answers

<p>A pointer to an object is a variable that stores the memory address of an object. It enables efficient access to the object's data and methods. For instance, you can directly access a member variable of an object using the pointer's arrow operator (-&gt;). Pointers to derived classes are used when dealing with inheritance. If you have a pointer to the base class, you can point it to an object of the derived class, allowing you to access the inherited members. This provides a mechanism for polymorphism and runtime type determination.</p> Signup and view all the answers

<p>Pure virtual functions, also known as abstract methods, are functions declared in a base class, but without a definition. These functions are denoted by adding &quot;= 0&quot; after the function declaration. Pure virtual functions have no implementation in the base class and instead require derived classes to provide their own implementations. They help in defining abstract base classes that act as templates for derived classes. The rules for virtual functions in C++ include: 1. Virtual functions should be declared in the base class. 2. They must be declared using the <code>virtual</code> keyword. 3. Derived classes can override virtual functions using the same name and signature. If a derived class does not override a virtual function, it inherits the implementation from the base class. 4. Virtual functions usually involve polymorphism, allowing derived classes to implement different behavior for the same function.</p> Signup and view all the answers

<p>The I/O stream class in C++ is a crucial part of the Standard Template Library (STL). With a hierarchy that provides a mechanism for input and output operations for various data types. The base class <code>ios</code> provides the basic functionality. <code>istream</code> (input stream) and <code>ostream</code> (output stream) classes are derived from <code>ios</code> for handling input and output operations respectively. The <code>fstream</code> class (file stream) inherits from both input and output streams and is used for file-based operations, while <code>stringstream</code> class is used for stream manipulation and conversion.</p> Signup and view all the answers

<pre><code class="language-c++">#include &lt;iostream&gt; #include &lt;fstream&gt; using namespace std; int main() { ifstream sourceFile(&quot;source.txt&quot;); ofstream destinationFile(&quot;destination.txt&quot;); if (sourceFile.is_open() &amp;&amp; destinationFile.is_open()) { string line; while (getline(sourceFile, line)) { destinationFile &lt;&lt; line &lt;&lt; endl; } sourceFile.close(); destinationFile.close(); cout &lt;&lt; &quot;File copied successfully.&quot;; } else { cout &lt;&lt; &quot;Unable to open files.&quot;; } return 0; } </code></pre> Signup and view all the answers

<p>Visual modeling employs diagrams and graphical representations to depict system structures, processes, and relationships. It uses techniques like UML (Unified Modeling Language), BPMN (Business Process Model and Notation), and other visual tools to communicate design ideas, analyze workflows, and understand system behavior. It helps in visualizing complex systems, facilitating communication between stakeholders, and aiding in the development process.</p> Signup and view all the answers

<p>A use case diagram for an institute could include actors like Students, Faculty, Administrators, and external entities like Prospective Students or Employers. Use cases could represent actions like: Enroll in courses, Submit assignments, View grades, Manage student records, Process admissions, Schedule classes, and Pay fees. The diagram would show how these actors interact with the institute system through various use cases. The diagram would illustrate relationships among actors and their roles in the institute's operations. Additionally, it could showcase how the system might work in conjunction with external entities like prospective students or employers.</p> Signup and view all the answers

<p>Command line arguments are values passed to a program upon execution. They are used to provide additional information or instructions to the program. For example, a program might take a filename or a specific option as an argument. In C++, command line arguments are accessed using the <code>main</code> function's <code>argv</code> parameter (argument vector). <code>argv[0]</code> holds the program name itself. Subsequent elements (e.g., <code>argv[1]</code>, <code>argv[2]</code>, etc.) contain the arguments provided by the user. Example: <code>./myprogram file.txt -option1</code> would pass &quot;file.txt&quot; and &quot;-option1&quot; as arguments. You can then parse these arguments within the program to control its behavior or pass custom values to it.</p> Signup and view all the answers

<p>C++ uses exceptions for handling runtime errors gracefully. Instead of relying on error codes or <code>return</code> values, exceptions allow you to separate error handling from the main program flow. The basic mechanism involves <code>try</code>, <code>catch</code>, and <code>throw</code> keywords:</p> <ol> <li> <strong><code>try</code> Block:</strong> Encloses code that might throw an exception.</li> <li> <strong><code>throw</code> Keyword:</strong> Raised when an error occurs.</li> <li> <strong><code>catch</code> Block:</strong> Handles specific exceptions thrown by code within the <code>try</code> block.<br /> Example:</li> </ol> <pre><code class="language-c++">#include &lt;iostream&gt; using namespace std; int main() { int a, b; cout &lt;&lt; &quot;Enter two numbers: &quot;; cin &gt;&gt; a &gt;&gt; b; try { if (b == 0) { throw &quot;Division by zero error!&quot;; } cout &lt;&lt; &quot;Division: &quot; &lt;&lt; a / b &lt;&lt;endl; } catch (const char* msg) { cout &lt;&lt; msg &lt;&lt; endl; } return 0; } </code></pre> <p>In this example, if <code>b</code> is 0, an exception is thrown, which is caught by the <code>catch</code> block and handled appropriately.</p> Signup and view all the answers

<p>Abstract classes are base classes that cannot be instantiated directly. They often contain one or more pure virtual functions that must be implemented by derived classes. This enforces a common interface for derived classes, even though they might have different concrete implementations. Example:</p> <pre><code class="language-c++">#include &lt;iostream&gt; using namespace std; class Shape { public: virtual double calculateArea() = 0; // Pure virtual function }; class Circle : public Shape { public: double radius; Circle(double r) : radius(r) {} double calculateArea() override { return 3.14159 * radius * radius; } }; class Rectangle : public Shape { public: double width, height; Rectangle(double w, double h) : width(w), height(h) {} double calculateArea() override { return width * height; } }; int main() { Circle c(5); Rectangle r(4, 3); cout &lt;&lt; &quot;Circle area: &quot; &lt;&lt; c.calculateArea() &lt;&lt; endl; cout &lt;&lt; &quot;Rectangle area: &quot; &lt;&lt; r.calculateArea() &lt;&lt; endl; return 0; } </code></pre> <p>Here, <code>Shape</code> is an abstract class with a pure virtual function. <code>Circle</code> and <code>Rectangle</code> derive from <code>Shape</code> and implement the <code>calculateArea</code> function.</p> Signup and view all the answers

<p>File modes in C++ determine how a file is opened for interaction with the program. Key parameters include:</p> <ol> <li> <strong><code>ios::in</code>:</strong> Opens a file for reading.</li> <li> <strong><code>ios::out</code>:</strong> Opens a file for writing.</li> <li> <strong><code>ios::app</code>:</strong> Appends data to the end of an existing file.</li> <li> <strong><code>ios::ate</code>:</strong> Starts at the end of the file.</li> <li> <strong><code>ios::trunc</code>:</strong> Truncates the existing file (cleans it).</li> <li> <strong><code>ios::binary</code>:</strong> Opens the file in binary mode.</li> <li> <strong><code>ios::noreplace</code>:</strong> Fails if the file is existing.</li> <li> <strong><code>ios::nocreate</code>:</strong> Fails if the file does not exist.</li> <li> <strong><code>ios::in | ios::out</code>:</strong> Opens the file for both reading and writing.<br /> The parameters can be combined using bitwise operators (e.g., <code>ios::in | ios::out</code> for read/write). The choice of mode depends on the specific file operation you intend to perform.</li> </ol> Signup and view all the answers

<p>Early binding (static binding) refers to resolving function calls during compile time. In early binding, the specific function to be called is determined before the program executes based on the data types of objects and functions. Late binding (dynamic binding), on the other hand, involves resolving function calls at runtime. This is often associated with virtual functions in C++. When a virtual function is called through a base class pointer, the actual function to be executed is determined based on the object's dynamic type at runtime. The appropriate function is selected based on the object's type. Early binding is more efficient, while late binding allows for greater flexibility and polymorphism.</p> Signup and view all the answers

<p>Private, public, and protected data members are access modifiers used in object-oriented programming to control how members of a class are accessed. They influence visibility and encapsulation.</p> <ol> <li> <strong>Private:</strong> Members declared as private are only accessible within the same class. They are hidden from outside access, ensuring data integrity and encapsulation.</li> <li> <strong>Public:</strong> Public members can be accessed from anywhere (within the class, derived classes, or external code). They define the class's interface.</li> <li> <strong>Protected:</strong> Protected members are accessible within the class, derived classes, and friend classes. They allow for limited access controlled by the class hierarchy. The use of access modifiers ensures data integrity and allows you to create well-defined boundaries for classes, promoting code modularity and reusability.</li> </ol> Signup and view all the answers