CPP

25 March 2024
20:24
In C++, a token is the smallest individual unit in a program. These units can be
classified into several categories:
1. Keywords: These are reserved words with predefined meanings in the C++ language,
such as int, class, if, else, etc.
2. Identifiers: These are names given to various program elements such as variables,
functions, classes, etc. They consist of letters, digits, and underscores and must begin
with a letter or an underscore.
3. Literals: Literals represent constant values that appear directly in the code. Examples
include integer literals like 10, floating-point literals like 3.14, character literals like
'a', and string literals like "Hello".
4. Operators: These symbols perform operations on operands. Examples include
arithmetic operators like +, -, *, etc., relational operators like ==, !=, >, etc., and
logical operators like &&, ||, !, etc.
5. Punctuators: These are special symbols used to punctuate expressions and statements.
Examples include braces {}, parentheses (), commas ,, etc.
6. Comments: These are used to annotate code and are ignored by the compiler. There
are two types: single-line comments (//) and multi-line comments (/* */).
this Pointer:
The this pointer is a keyword in C++ that is a pointer to the object itself. It is used to
access members of the current object within a class method. Here's an example:

Abstract Class:
An abstract class is a class that cannot be instantiated on its own and is meant to be
subclassed. It often contains one or more pure virtual functions, making it an
incomplete type. Abstract classes are used to define an interface that must be
implemented by derived classes. Here's an example:

cppCopy code
classShape{ public: // Pure virtual functionvirtualvoiddraw()= 0; // Normal member
functionvoiddisplay(){ std::cout << "Displaying shape."<< std::endl; } }; classCircle:
publicShape { public: voiddraw()override{ std::cout << "Drawing Circle."<< std::endl; } };
intmain(){ // Shape shape; // Error: Cannot instantiate abstract classCircle circle;
circle.draw(); circle.display(); return0; }
In this example, Shape is an abstract class with a pure virtual function draw(). The
Circle class inherits from Shape and provides an implementation for the draw()
function.
Constructor & Destructor:
 Constructor: A constructor is a special member function with the same name as the
class. It is automatically called when an object of the class is created. Constructors
are used to initialize the object's state. They can be overloaded to accept different
parameters.
 Destructor: A destructor is also a special member function with the same name as the
class but preceded by a tilde (~). It is automatically called when an object goes out of
scope or is explicitly deleted. Destructors are used to release resources acquired by
the object during its lifetime, such as dynamic memory allocation.
Friend Function:
A friend function in C++ is a function that is not a member of a class but has access to
the class's private and protected members. It is declared with the friend keyword
 inside the class. Friend functions are often used when external functions need access
to private or protected members of a class without explicitly being a member of that
class.
Compile Time Polymorphism:
Compile-time polymorphism, also known as static polymorphism, refers to the
mechanism of selecting the appropriate function or operator at compile time. This is
achieved through function overloading and operator overloading. Function
overloading allows multiple functions with the same name but different parameters in
the same scope, while operator overloading allows operators to be redefined to work
with user-defined types.
Inline Function:
An inline function is a function that is expanded in place at the point of call rather
than being invoked through a function call mechanism. It is declared with the inline
keyword. Inline functions are typically small and simple, and the compiler decides
whether to actually inline the function or not based on optimization settings and other
factors.
Manipulators:
Manipulators are special functions or objects in C++ that are used with the output
stream (cout) to modify the output formatting. Two commonly used manipulators are:
1. std::setw(int n): Sets the width of the next output field to n characters.
2. std::setprecision(int n): Sets the number of digits to be displayed after the decimal
point for floating-point numbers to n.
Extraction and Insertion Operators:
Extraction and insertion operators (<< and >>) are used for input and output
operations in C++ streams.
 Extraction Operator (>>): Reads data from the input stream (e.g., keyboard, file) into
variables.
 Insertion Operator (<<): Writes data from variables to the output stream (e.g.,
console, file).

From <https://chat.openai.com/c/041b741d-ab38-4909-b1e7-cf994983ed70>
What is tokens in C++? Explain in detail.

Explain this pointer with suitable example.

Explain Abstract class in detail

Explain use of this pointer.

What is Constructor & Desturctor.

What is Friend function

What is compile time polymorphism?

What is Inline Function?

Explain any two manipulators.

What is Extraction and Insertion Operator?

Explain Memory Management operators with the help of examples.

When do we make a class a virtual base class? Explain it with suitable example.

Differentate between Call by Value & Call by Reference

Explain any 4 formatted input/output functions.

What is default argument?

What are the access specifiers used in C++?

What is reference variable? What is its major use?

Memory Management Operators:

cppCopy code
int*ptr = newint; // Allocating memory for an integer*ptr = 10; // Assigning value to the
dynamically allocated memorydeleteptr; // Deallocating memory
Function Overloading:
Function overloading in C++ allows you to define multiple functions with the same
name but with different parameter lists. The compiler determines which function to
call based on the number and types of arguments passed to it.
Example of function overloading:

cppCopy code
#include<iostream>voiddisplay(intnum){ std::cout << "Integer: "<< num << std::endl; }
voiddisplay(doublenum){ std::cout << "Double: "<< num << std::endl; } intmain(){
display(5); // Calls the first functiondisplay(3.14); // Calls the second functionreturn0; }
Virtual Base Class:
A virtual base class is used in multiple inheritance scenarios to avoid the creation of
duplicate base class objects when a derived class inherits from multiple paths. It
ensures that only one instance of the base class is inherited by the derived class.
Example:

cppCopy code
#include<iostream>classBase{ public: intdata; }; classDerived1: virtualpublicBase { };
classDerived2: virtualpublicBase { }; classMultipleDerived: publicDerived1, publicDerived2
{ }; intmain(){ MultipleDerived obj; obj.data = 10; // Accessing the data member of the
virtual base classreturn0; }
Call by Value vs Call by Reference:
 Call by Value: In call by value, a copy of the actual parameter is passed to the
function. Any changes made to the parameters inside the function do not affect the
original values.
 Call by Reference: In call by reference, the memory address of the actual parameter is
passed to the function. Any changes made to the parameters inside the function affect
the original values.
Formatted Input/Output Functions:
Some commonly used formatted input/output functions in C++ are:
 setw(int n): Sets the width of the next output field to n characters.
  setprecision(int n): Sets the number of digits to be displayed after the decimal point
for floating-point numbers to n.
 fixed: Specifies that floating-point numbers should be printed in fixed-point notation.
 left and right: Aligns output to the left or right within the specified width.
Default Argument:
A default argument is a value provided in the function declaration that is used when
the corresponding argument is not provided during the function call.
Example:

cppCopy code
#include<iostream>voidgreet(std::string name = "Guest"){ std::cout << "Hello, "<< name <<
"!"<< std::endl; } intmain(){ greet(); // Output: Hello, Guest!greet("John"); // Output: Hello,
John!return0; }
Access Specifiers in C++:
In C++, there are three access specifiers:
 public: Members declared as public are accessible from outside the class through
objects.
 private: Members declared as private are only accessible from within the class.
 protected: Similar to private, but accessible in derived classes.
Reference Variable:
A reference variable in C++ is an alias, or alternative name, for an existing variable. It
is declared using the & symbol and must be initialized when declared. Its major use is
to provide an alternative name for a variable and to pass variables by reference to
functions.

From <https://chat.openai.com/c/041b741d-ab38-4909-b1e7-cf994983ed70>