OOPS(Unit-3&4)

A Destructor is a special member function that is automatically called when an object goes out of scope or is explicitly deleted, primarily to free resources.

It creates a Book object, displays the book title, and automatically calls the destructor when the object goes out of scope.

Negated: Vector (-3, -4)

The Destructor is called automatically when the 'Sample' object goes out of scope.

It outputs the book title to the console.

A Copy Constructor initializes an object from another object of the same class.

friend Vector operator +(const Vector &v1, const Vector &v2)

The output will indicate that the Destructor has been called, as shown in the example with 'Destructor called!'.

To initialize width and height with default arguments.

The destructor frees the allocated memory for the array.

It allows the operator + function to access private members of the Vector class.

The destructor frees the allocated memory for the book title and outputs a message indicating that memory has been freed.

Vector (6, 8)

The function used is 'strcpy'.

The private member variables are x and y.

Width and height default to 1.

The program will output an error message and return 1.

If you don't define any constructors, the compiler provides a default constructor with no parameters.

A constructor helps initialize an object of the class.

Vector (6, 8)

Point p2 (4, 5); // Create point p2

It displays 'Book Title: C++ Programming'.

Vector(int x = 0, int y = 0) : x(x), y(y) {}

It prints 'Result of p1 + p2:' to the console.

Constructor overloading allows you to have multiple constructors in a class, enabling the creation of objects in different ways based on provided arguments.

Destructors are called automatically when an object goes out of scope or is deleted. You do not need to call them explicitly.

It checks using 'if (!sourceFile)' and prints an error message if it fails to open.

The program checks if the input file is open.

It initializes the vector's x and y coordinates.

It returns a new Vector object with negated coordinates (-v.x, -v.y).

Memory is allocated using 'new' with the size determined by the length of the title plus one for the null terminator.

It allocates memory dynamically for an array of a given size and initializes the array with values.

The get() function is used to read a single character from a file.

No, constructors do not have a return type, not even void.

It prints the elements of the array to the console.

When the size of an object's data members is not known at compile time, when you need to create objects that can grow or shrink dynamically during runtime, or when you want to avoid wasting memory by allocating only the memory that is needed.

The return type of an overloaded operator can be any type, including class type.

The compiler automatically selects the appropriate constructor based on the arguments provided when creating an object.

std::endl is used for a newline and flushing the buffer.

Original: Vector (3, 4)

It displays the vector in the format Vector(x, y).

istream stands for input stream and is derived from ios, handling input streams from files.

Operators can be overloaded as member functions or friend functions.

The put() function is used to write a single character to a file.

Use std::fixed along with std::setprecision(n) to format the output to a fixed-point number with n decimal places.

The getArea() function calculates the area of the rectangle.

The destructor of the derived class is called first, followed by the destructor of the base class.

The program uses 'std::getline(sourceFile, line)' to read lines.

Constructors are used to initialize the data members of the object.

It adds two point objects p1 and p2 to create p3.

It prints 'Destructor called: Memory freed for title "C++ Programming"'.

The insertion operator (<<) is used to insert data into an output stream, typically cout for standard output.

The overloaded operator should maintain the meaning and functionality of the original operator as much as possible.

It manages a dynamically allocated array and its size.

It prints the components of the vector in the format 'Vector(x, y)'.

The display() function outputs the dimensions of the rectangle.

A constructor that does not take any parameters and initializes objects with default values.

If no values are provided, the dimensions are initialized to width and height of 1.

Rectangle 1 has a width of 1 and a height of 1.

The constructor with two parameters takes integers 'w' and 'h' and initializes width and height to those values respectively.

The get() function is used to read data from a file.

The endl manipulator inserts a newline character and flushes the output buffer.

setw(n) sets the width of the next output field to n characters.

setfill(c) fills the empty spaces in a field with the character c.

It allows copying objects, useful for passing objects by value or returning them from functions.

scientific sets the output format for floating-point numbers to scientific notation.

dec sets the output format to decimal, which is the default.

cout is an instance of the ostream class that is used for standard output.

Any remaining bytes in the buffer are written to the output file using outputFile.write() after the main reading loop.

It frees resources that the object may have acquired during its lifetime, such as dynamic memory, file handles, or network connections.

ios stands for input output stream and is the base class for other classes in the file stream hierarchy.

The constructor has the same name as the class.

ostream stands for output stream and is derived from ios, handling output streams to files.

You can have multiple constructors in a class with different parameter lists.

Each constructor must have a unique parameter list, either by having a different number of parameters or different types.

The extraction operator (>>) is used to extract data from an input stream, typically cin for standard input.

Original: Vector(3, 4)

To ensure that the destructor of the derived class is called when an object of the derived class is deleted through a base class pointer.

Operators such as ::, ., .*, and ?: cannot be overloaded.

The get() and put() functions are used to work with a file on disk.

Each operator can only be defined once per scope.

A constructor is called when an instance or object of a class is created.

A dynamic constructor is a constructor that allocates memory dynamically using the new operator during the object's creation.

It allows the creation of objects with custom initial values.

class Rectangle { public: Rectangle(int w, int h) { width = w; height = h; } };

A constructor that initializes an object using another object of the same class.

Exclusive creation mode creates a new file but raises an error if the file already exists.

Read-write mode is similar to 'r+', but it truncates the file, removing its existing contents.

The fstream class is used for file input and output operations in C++.

The ios_base class stores formatting information and the state of the stream.

The functionality of ios_base and basic_ios is usually accessed through other classes, such as iostream, which inherit them.

It prints the coordinates of the vector.

By multiplying width and height in the getArea() function.

By calling the dynamic constructor with the size entered by the user.

You define a member function in your class that returns a new object created by adding the corresponding data members of the current object and the passed object.

A special constructor that initializes an object using another object of the same class.

The default constructor initializes width and height to 0.

Use std::setw(width) to set the width and std::setfill(character) to specify the fill character for the output.

Yes, a constructor can either accept arguments or not.

The destructors for global and static objects are called when the program terminates, in the reverse order of their construction.

The display function is used to show the point's coordinates.

The seekg() function moves the read position to a specified location in the file.

Yes, constructors can be overloaded.

The constructor's name is the same as the class name.

A class can have only a single destructor.

fixed sets the output format for floating-point numbers to fixed-point notation.

The ostream class is used for output operations in C++.

If the output file fails to open, an error message is displayed and the program returns 1.

You define 'Vector operator - () { return Vector(-x, -y); }' within the class.

Vector v(3, 4); // Creates a vector with coordinates (3, 4)

It outputs the width and height of the rectangle.

No, you cannot change the precedence or associativity of operators.

The display function outputs the coordinates of the vector in a readable format.

It closes both the source and destination files and prints a success message.

To free resources acquired during the lifetime of an object, such as dynamically allocated memory, to prevent memory leaks.

The output will display the value of pi in scientific notation, for example, 'Scientific: 3.141593e+00'.

To print the coordinates of the vector in the format: Vector(x, y)

The fstreambase class provides operations common to file streams and serves as a base for fstream, ifstream, and ofstream classes. It contains open() and close() functions.

You can open a file using the open() function with 'r+' mode, like f = open('myfile.txt', 'r+').

They are used for reading from and writing to files in binary mode.

Binary mode is used for working with binary files, such as images and audio files. For example, 'rb' is used to read a binary file, and 'wb' is used to write to a binary file.

You can check if the input file is open by using an if statement: if (!inputFile).

hex sets the output format to hexadecimal.

The cin instance is an instance of the istream class that reads data from the keyboard.

cerr is an instance of the ostream class that is used to print error results.

After successfully copying the data, the program closes both files and prints a success message to the console.

Cascading allows you to chain multiple I/O operators together to perform several operations in a single statement.

Using a friend function: friend Vector operator-(const Vector &v);

It initializes objects with default values.

Negated: Vector(-3, -4)

The streambuf class contains a pointer that points to the buffer used to manage input and output streams.

I/O manipulators are functions that modify the behavior of input and output streams, typically used with cout and cin to format output or interpret input.

Rectangle 3 has a width of 4 and a height of 6.

You can read the first byte using inputFile.get(ch); after opening the file.

You can move to the 5th byte by using inputFile.seekg(4, std::ios::beg);.

The output will display the byte read from the 5th position of the file.

Update mode opens a file for both reading and writing. For example, 'r+' is used to open a file for both reading and writing.

It is important to close a stream when done using it to prevent corruption, especially for output files.

It uses the default arguments (1, 1).

The constructor initializes the vector's coordinates x and y, defaulting to 0 if no values are provided.

class Rectangle { public: Rectangle() { width = 0; height = 0; } };

You can open a binary file for reading using std::ifstream inputFile("example.bin", std::ios::binary);

The method 'getArea()' calculates the area by returning the product of width and height.

They allow you to create objects whose size is not known at compile time, useful for data structures like strings, arrays, or linked lists.

If the destructor is not implemented correctly or if exceptions are thrown during object creation, memory leaks can occur.

The size of the data buffer is defined as 100.

No, there is no copy destructor concept.

The iostream class is used for input and output operations in C++.

The header files iostream and fstream are commonly used to work with streams in C++.

The content is written to destination.txt.

Constructors can have public, protected, or private access specifiers.

The constructor with one parameter takes an integer 'size' and initializes both width and height to that size.

The put() function is used to write data to a file.

Rectangle 2 has a width of 5 and uses the default height of 1.

A destructor is used to deallocate the memory of an object of a class.

The ifstream class provides input operations and contains an open() function with the default input mode. It inherits functions like get(), getline(), read(), seekg(), and tellg() from istream.

The three main classes are fstream (for both reading and writing), ifstream (for reading), and ofstream (for writing).

File modes specify how a file can be opened: Read mode (for reading), Write mode (for writing and overwriting), and Append mode (for adding new content).

You can move back to the 2nd byte using inputFile.seekg(1, std::ios::beg);.

oct sets the output format to octal.

The basic_ios class manages the associated stream buffer.

The read() function is used to read a specific number of bytes from a file into a buffer, allowing you to specify where the data will be stored and how many bytes to read.

A destructor is declared as ~className() without any arguments.

Width: 1, Height: 1

The write() function is used to write data from a buffer to a file, specifying the number of bytes to write.

The output will be 'Result of v1 + v2: Vector(6, 8)'

A constructor that takes parameters to initialize an object with specific values.

The + operator is overloaded by defining a member function that returns a new Point object with the sum of the coordinates.

Operator overloading is a feature that allows defining custom behavior for operators when used with user-defined types.

It allows operators to be used with objects in a way that is intuitive and resembles built-in types.

setprecision(n) sets the precision for floating-point numbers to n digits.

An error message is displayed, and the program returns 1.

The outputFile.write() function writes the number of characters read from the input file into the output file.

The program includes , , and libraries.

The program reads text from 'source.txt' and writes it to 'destination.txt'.