Can C/C++ run without main function?

Yes and No.

No (simple answer): you cannot write a c program in standard c compiler without main
function. You can do few tricks with macro but then it is actually calling main function
only.

Yes(complex answer): Main() is actually started by _start() method while run-time. this
_start() method search for main and calls it . You can override this _start() and can give
other name. This is not part of standard c/c++.

Macro Tricks are simple and you can google for them.

#include<stdio.h>
#define start_program main

void start_program()
{
printf("Hello world");
}

TCS C/C++ Questions

1. Difference between "C structure" and "C++ structure".
2. Diffrence between a "assignment operator" and a "copy constructor"
3. What is the difference between "overloading" and "overridding"?
4. Explain the need for "Virtual Destructor".
5. Can we have "Virtual Constructors"?
6. What are the different types of polymorphism?
7. What are Virtual Functions? How to implement virtual functions in "C"
8. What are the different types of Storage classes?
9. What is Namespace?
10. What are the types of STL containers?.
11. Difference between "vector" and "array"?
12. How to write a program such that it will delete itself after exectution?
13. Can we generate a C++ source code from the binary file?
14. What are inline functions?
15. What is "strstream" ?
16. Explain "passing by value", "passing by pointer" and "passing by reference"
17. Have you heard of "mutable" keyword?
18. What is a "RTTI"?
19. Is there something that I can do in C and not in C++?
20. What is the difference between "calloc" and "malloc"?
21. What will happen if I allocate memory using "new" and free it using "free" or allocate using
"calloc" and free it using "delete"?
22. Difference between "printf" and "sprintf".
23. What is "map" in STL?
24. When shall I use Multiple Inheritance?
25. Explain working of printf.
26. Talk sometiming about profiling?
27. How many lines of code you have written for a single program?
28. How to write Multithreaded applications using C++?
29. Write any small program that will compile in "C" but not in "C++"
30. What is Memory Alignment?
31. Why preincrement operator is faster than postincrement?
32. What are the techniques you use for debugging?
33. How to reduce a final size of executable?
34. Give 2 examples of a code optimization.

C++ in a nutshell:

Answer:-

C++ is a clever language that can do a lot of things. It’s like having a toolbox full of tools that can build
almost anything you want on a computer. It’s easy to use, but it’s also quite powerful, like a
superhero in the coding world.

Where C++ is used?

1. Systems Programming: Operating systems, drivers.

2. Game Development: Video games, game engines.

3. High Performance: Simulations, scientific computing.

4. Embedded Systems: IoT, microcontrollers.

5. Graphics: Graphics libraries, computer vision.

6. Financial Software: Trading, risk analysis.

7. Networking: Protocols, communication systems.

8. Real-Time: Robotics, industrial automation.

9. Library Development: Reusable components.

10. Cross-Platform: Write once, run on different OS.

11. Open Source: Many projects.

12. HPC: Scientific simulations, clusters.

C++ excels where performance, control, and efficiency are vital.

C++ Interview Questions and Answers For Freshers

Ques 1: What is C++?

Ans.C++ is a general-purpose programming language that extends the capabilities of the C

programming language. It supports both high-level features for easier programming and low-level
features for direct hardware manipulation. C++ is widely used for developing software applications,
games, system software, and more due to its performance, flexibility, and object-oriented features.

Ques 2: What are Class and Object? Explain with example.

Ans. In C++, a class is a blueprint defining attributes (data members) and behaviors (methods) of
objects. An object is an instance of a class, embodying its attributes and capable of performing its
actions. For instance:

Example:

In this example, the Smartphone class defines the structure and behavior of a smartphone, and
the myPhone object is a specific instance of that class, representing a smartphone with its own
attributes and capabilities. Just as in programming, classes and objects help categorize and represent
entities with shared characteristics and actions.

Ques 3: Difference between C and C++.

Ans.

Aspect C C++

Programming Paradigm Procedural

Object-
Oriented

Object-Oriented Data Data is not hidden; No Encapsulation ensures controlled access

Hiding and Encapsulation : encapsulation to data; Data hiding supported

Relationship: Subset of C++ C++ extends C, adding OOP features

Standard Libraries: Not supported Function overloading and operator

overloading are supported

Namespace: Not present Namespaces introduced to prevent

naming collisions

Functions Inside Structures Functions cannot be defined Member functions (methods) can be
inside structures defined within classes
 Aspect C C++

Memory Management Memory managed using `new` operator for memory allocation,
`calloc()`, `malloc()`,` free()` `delete` operator for `deallocation`

Ques 4: Explain Operators and with example?

Ans.

Operators in programming are symbols that define actions on operands. They’re vital for arithmetic,
comparisons, logic, and more. Here’s a quick overview of key operator types in C++:

Aspect Operators

Arithmetic Operators: +–*/%

Comparison Operators: == != > < >= <=

Logical Operators: && || !

Assignment Operators: = += -= *= /= %=

Increment/Decrement Operators: ++ —

Bitwise Operators: &|^~

Ques 5: What is Virtual functions?

Ans. Virtual function is a member function of a base class that can be overridden in a derived class.
When a function is declared as “virtual,” it enables dynamic polymorphism, which means that the
appropriate function to be called is determined at runtime based on the actual object’s type. This
allows for more flexible and extensible code, particularly when dealing with inheritance and class
hierarchies.

Ques 6: Compare Overloading Function Overriding Function.

Ans.
 Aspect Function Overloading Function Overriding

Definition Multiple functions with same Providing a new implementation of a virtual

name but different parameter function in a derived class that overrides the base
lists within the same class or class’s version.
namespace.

Parameters Functions have different Functions must have the same name, return type,
parameter lists (type and/or and parameters (signature) as the base class’s
number of parameters). virtual function.

Access: Can be used to provide multiple Used to customize the behavior of a function
variations of a function within inherited from the base class.
the same scope.

Keyword No special keyword is required. The `virtual` keyword is used in the base class for
Usage functions intended to be overridden. The override
keyword is used in the derived class to ensure
proper overriding.

Example cpp void print(int num); void cpp class Shape { public: virtual void draw(); };
print(double num); class Circle : public Shape { public: void draw()
override; };

Ques 7: Explain the concept of Polymorphism in c++?

Ans. Virtual function is a member function of a base class that can be overridden in a derived class.
When a function is declared as “virtual,” it enables dynamic polymorphism, which means that the
appropriate function to be called is determined at runtime based on the actual object’s type. This
allows for more flexible and extensible code, particularly when dealing with inheritance and class
hierarchies.

For Example:

Imagine a “Shape” class with a “draw” method. Different shapes like “Circle,” “Rectangle,” and
“Triangle” are subclasses of “Shape.” Even though each shape’s “draw” method is different, they’re
all accessed and used in the same way. This is polymorphism in action – different shapes sharing a
common interface (“draw”) but behaving differently based on their individual implementations.

There are Two Types of Polymorphism.

• Compile Time

• Run Time
Ques 8: Explain function overloading.

Ans.Function overloading refers to defining multiple functions with the same name but different
parameter types or counts. This allows you to use the same function name for operations that
conceptually do the same thing but with different inputs. Example:

class #include

class Calculator {

public:

int add(int a, int b) {

return a + b;

double add(double a, double b) {

return a + b;

};

int main() {

Calculator calc;

std::cout << calc.add(5, 10) << std::endl; // Calls int add(int a, int b)

std::cout << calc.add(3.14, 2.71) << std::endl; // Calls double add(double a, double b)

return 0;

In this example, the Calculator class has two add methods with different parameter types (int and
double). Depending on the parameter types passed when calling the add function, the appropriate
version of the function is invoked. This is function overloading in action.

Ques 9: What is the significance of the const keyword in C++?

Ans. The const keyword in C++ is used to indicate that a variable or function won’t be modified after
its initialization. It’s crucial for maintaining code correctness and preventing accidental changes to
values. It’s used with variables, function parameters, member functions, and pointers to ensure code
quality and reliability.

Ques 10: Explain the importance of the main() function in a C++ program.
Ans. The main() function is vital in a C++ program as it’s where execution begins. When the program
is run, the operating system calls main(). It’s responsible for organizing the program’s actions, user
interactions, and function calls. You structure the program’s logic within main(), and it often utilizes
functions you’ve defined. Additionally, main() can return an integer value, typically 0 for success and
non-zero for errors. In essence, it’s the entry point and central control hub of a C++ program.

• Starting Point: main() is the entry point of a C++ program, where execution begins upon
running the program.

• Program Logic: It holds the high-level logic, orchestrating tasks, operations, and interactions.

• User Interaction: main often uses input/output functions (cin, cout)to communicate with
users.

• Function Calls: It coordinates the execution of functions defined in the program.

• Return Value: main() can provide a return value to the operating system, indicating success
or errors.

• Control Hub: It’s the core of the program’s structure and execution, directing its flow and
actions.

C++ Interview Questions With Answers

Ques 11: What is a constructor and a destructor? How are they different?

Ans. A constructor is a special function in a class that gets automatically called when an object of
that class is created. It’s used to initialize the object’s attributes and set up any required resources.

A destructor, on the other hand, is another special function that’s automatically called when an
object goes out of scope or is explicitly deleted. Its purpose is to clean up resources that the object
acquired during its lifetime.

In short, constructors initialize objects, while destructors clean up objects before they are removed
from memory.

Constructors:

• Initialize objects upon creation.

• Automatically invoked during object instantiation.

• Same name as the class, no return type.

• Can be overloaded with different parameter sets.

• Set initial values and allocate resources.

Destructors:

• Clean up resources before destruction.

• Automatically invoked when object goes out of scope or is deleted.

• Named with ~ followed by class name, no parameters.

• Release allocated resources and perform final actions.

Ques 12: What is the difference between malloc and new in C++?

Ans.

Malloc:

• malloc is a C standard library function available in.

• It doesn’t have any idea about the type of memory it’s allocating; it deals with bytes.

• Since it doesn’t know about types, it doesn’t invoke constructors or initializations.

• It returns a raw pointer of type void*, which requires explicit casting to the desired pointer
type.

• It doesn’t handle exceptions natively; if allocation fails, it returns a nullptr.

new:

• new is a C++ operator that handles dynamic memory allocation.

• It’s more integrated with C++ features and knows the type it’s allocating memory for.

• It invokes constructors for objects being created in the allocated memory.

• It returns a pointer to the specific type being allocated, so casting is not needed.

• If memory allocation fails, it throws a std::bad_alloc exception.

Ques 13: Explain Inheritance

Ans.

Inheritance is a core concept in object-oriented programming where a new class can inherit
properties and behaviors from an existing class. It promotes code reuse and hierarchy creation:

• Code Reuse: Avoids duplication by inheriting code from a base class.

• Single & Multiple Inheritance: Inherits from one or more classes.

• Method Overriding: Customizes inherited methods in derived classes.

• Polymorphism: Allows treating different classes as one type.

• Access Control: Manages visibility of inherited members.

Ques 14: Explain friend class and friend function.

Ans.

Friend Function: A friend function is a non-member function that is granted access to a class’s
private and protected members.

Friend Class: A friend class is a class that is allowed to access the private and protected members of
another class.

Example:
#include

using namespace std;

class MyClass {

private:

int secretValue;

// Declare friend function and class

friend void friendFunction(MyClass& obj);

friend class FriendClass;

public:

MyClass(int value) : secretValue(value) {}

};

void friendFunction(MyClass& obj) {

cout << "Accessing private member through friend function: " << obj.secretValue << std::endl;

class FriendClass {

public:

void accessPrivateMember(MyClass& obj) {

cout << "Accessing private member through friend class: " << obj.secretValue << std::endl;

};

int main() {

MyClass obj(42);

friendFunction(obj);

FriendClass friendObj;
 friendObj.accessPrivateMember(obj);

return 0;

Ques 15: Explain inline function and provide an example of how it can be used in C++.

Ans.

An inline function in C++ is a function whose code is inserted directly into the calling code, reducing
the overhead of function calls. It’s declared using the inline keyword before the function declaration.
Here’s a short example:

#include <iostream>

// Inline function declaration

inline int multiply(int a, int b) {

return a * b;

int main() {

int result = multiply(3, 4);

std::cout << "Result: " << result << std::endl;

return 0;

C++ Questions Asked In Interviews

Ques 16: What is STL?

Ans.

STL stands for “Standard Template Library” in C++. It’s a collection of template classes and functions
that provide common data structures (containers) like vectors, lists, and maps, as well as algorithms
(sorting, searching) and iterators for efficient data manipulation. The STL enhances code reusability
and productivity by offering a standardized set of tools for various programming tasks.

Ques 17 :Define namespace in C++?

Ans.

A namespace is a declarative region that provides a scope to the identifiers (the names of types,
functions, variables, etc) inside it. Namespaces are used to organize code into logical groups and to
prevent name collisions that can occur especially when your codebase includes multiple libraries.
The namespace is a logical division of the code that is designed to stop the naming conflict.
The namespace defines the scope where the identifiers such as variables, class, functions are
declared.
C++ consists of a standard namespace, i.e., std which contains inbuilt classes and functions. So, by
using the statement “using namespace std;” includes the namespace “std” in our program.
The main purpose of using namespace in C++ is to remove ambiguity. Ambiguity occurs when a
different task occurs with the same name.

For example: if two functions exist with the same name such as add(). To prevent this ambiguity, the
namespace is used. Functions are declared in different namespaces.

Syntax of the namespace:

namespace namespace_name

//body of namespace;

Ques 18: Explain what is C++ exceptional handling?

Ans.

One of the advantages of C++ over C is Exception Handling. Exceptions are run-time anomalies or
abnormal conditions that a program encounters during its execution.

The problem that arises during the execution of a program is referred to as exceptional handling. The
exceptional handling in C++ is done by three keywords.

• try: represents a block of code that can throw an exception.

• catch: represents a block of code that is executed when a particular exception is thrown.

• throw: Used to throw an exception. Also used to list the exceptions that a function throws,
but doesn’t handle itself.

Ques 19: Define Pointers?

Ans.

• Pointes is a special type of variables that are used to store the memory address of the other
variables.

• Pointers are declared normally as other variables with a difference of * that is present in
front of the pointer identifier.

• There are two operators that are used with the pointers one is ‘&’ and another one is ‘*’. & is
known as the address of operator and * is known as dereferencing operator, both are prefix
unary operators.

Ques 20: What is the output of the following code:

Ans.

#include <iostream>
class A {

public:

A() {}

~A() {

throw 42;

};

int main(int argc, const char * argv[]) {

try {

A a;

throw 32;

} catch(int a) {

std::cout << a;

Solution:-

This program will terminate abnormally. throw 32 will start unwinding the stack and destroy class A.

The class A destructor will throw another exception during the exception handling, which will cause
the program to crash.

Ques 21: What is references and pointers?

Ans.

Pointers: A pointer is a variable that holds the memory address of another variable. A pointer needs
to be dereferenced with the * operator to access the memory location it points to.

References: A reference variable is an alias, that is, another name for an already existing variable. A
reference, like a pointer, is also implemented by storing the address of an object.
A reference can be thought of as a constant pointer (not to be confused with a pointer to a constant
value!) with automatic indirection, i.e the compiler will apply the * operator for you.

• References are less powerful than pointers:

1) Once a reference is created, it cannot be later made to reference another object; it cannot
be reseated. This is often done with pointers.
2) References cannot be NULL. Pointers are often made NULL to indicate that they are not
 pointing to any valid thing.
3) A reference must be initialized when declared. There is no such restriction with pointers

• References are safer and easier to use:

1) Safer: Since references must be initialized, wild references like wild pointers are unlikely to
exist. It is still possible to have references that don’t refer to a valid location (See questions 5
and 6 in the below exercise )
2) Easier to use: References don’t need dereferencing operator to access the value. They can
be used like normal variables. ‘&’ operator is needed only at the time of declaration. Also,
members of an object reference can be accessed with dot operator (‘.’), unlike pointers
where arrow operator (->) is needed to access members.

Ques 22: What is equal to (==) and Assignment Operator (=)?

Ans.

In C++, equal to (==) and assignment operator (=) are two completely different operators.

• The assignment operator (=) is used to assign a value to a variable. Hence, we can have a
complex assignment operation inside the equality relational operator for evaluation.

• Equal to (==) is an equality relational operator that evaluates two expressions to see if they
are equal and returns true if they are equal and false if they are not.

Ques 23: Which operations are permitted on pointers?

Ans.

In C++ programming the following operations are allowed to perform on pointers:

Incrementing or decrementing a pointer: Incrementing a pointer means that we can increment the
pointer by the size of a data type to which it points.

There are two types of increment/decrement pointers:

1. Pre-increment/decrement pointer: The pre-increment/decrement operator increments the

operand by 1, and the value of the expression becomes the resulting value of the
incremented/decremented. Suppose ptr is a pointer then pre-increment/decrement pointer
is represented as ++ptr.

2. Post-increment/decrement pointer: The post-increment/decrement operator increments

the operand by 1, but the value of the expression will be the value of the operand prior to
the incremented/decremented value of the operand. Suppose ptr is a pointer then post-
increment/decrement pointer is represented as ptr++.

Ques 24: Mention what are the decision-making statements in C++?

Ans. The major decision making statements in C++ are

• if statement

• switch statement

• conditional operator

For example, we want to implement if condition in C++

#include

int main ( )

int, x, y;

X= 10;

Y= 5;

if (x > y)

Cout << "x is greater than y";

Cpp Interview Questions and Answers

Ques 25: What is Between Global Variables And Static Variables?

Ans.

Global variables: Global variables are variables that are defined outside the function. The scope of
global variables begins at the point where they are defined and lasts till the end of the file/program.
They have external linkage, which means that in other source files, the same name refers to the
same location in memory. The scope of the global variables remains throughout the program also the
life span of these variables is throughout the program.

Static variables: Static variables are private to the source file where they are defined and do not
conflict with other variables in other source files which would have the same name. The scope of the
variable describes whether the variable is accessible at a certain point in the program or not.

Ques 26: How many times will this loop execute? Explain your answer.

Ans.

unsigned char half_limit = 150;

for (unsigned char i = 0; i < 2 * half_limit; ++i)

// do something;

Solution:-
This code will result in an infinite loop.

Here’s why:

The expression 2 * half_limit will get promoted to an int (based on C++ conversion rules) and will
have a value of 300. However, since i is an unsigned char, it is represented by an 8-bit value which,
after reaching 255, will overflow (so it will go back to 0) and the loop will therefore go on forever.

Ques 27: What is the role of protected access specifier?

Ans.

A class member is accessible in the inherited class if the class member is protected. However, outside
both the private and protected members are not accessible.

Ques 28: Distinguish between shallow copy and deep copy.

Ans.

Shallow copy performs bit-by-bit memory dumping from one object to another. Deep copy is the
process of copying an object field by field from one object to another. The copy function Object() {
[native code] } and the overloading assignment operator are used to achieve deep copy.

Ques 29: Explain what is C++ exceptional handling?

Ans.

The following are storage classes supported in C++ :

• auto

• static

• extern

• register

• mutable

Ques 30: What is the role of a mutable storage class specifier?

Ans.

The member variable of a constant class object may be used by declaring it with the mutable storage
class specifier. Just applies to the class’s non-static and non-constant member variables. doesn’t
handle itself.

Ques 31: What is a class template?

Ans.

A template class is a prototype class. A template class can be described using the keyword template.

Ques 32: What Is The Memory Structure Of An Object?

Ans.

Usually C++ objects are made by concatenating member variables.

For example;

class Test

int I;

float j;

};

It is represented by an int followed by a float.

class TestSub: public Test

int k;

};

The above class is represented by Test and then an int(for int k). So finally it will be int, float, and int.

In addition to this, each object will have the vptr(virtual pointer) if the class has the virtual function,
usually as the first element in a class.

Ques 33: Define Encapsulation in C++?

Ans.

The process of encapsulating data and functions in a class is called encapsulation. For security
purposes, it is used to prevent direct access to data. This is accomplished by using class functions.

For example, the net banking facility for customers allows only the approved person with the proper
login id and password to access the information in the bank data source, and only for his or her part
of the information.

Ques 34: What Is The Difference Between Exit And Abort?

Ans.
 • Exit performs a graceful process termination by invoking the destructors for all constructed
objects, while abort does not.

• Exiting the local The destructors of the calling functions and its callers’ variables will not be
called.

Ques 35: Write C++ code to create an array of objects using a new keyword and delete these
objects. Also, proof that all the objects are deleted properly.

Ans.

C++ not only preserves all elements of the C language, but it also simplifies memory management
and introduces many new features, such as:

We know that when we generate a class object dynamically from heap memory with the new
keyword, we must specifically delete it after we are finished with its operations to prevent memory
leaks in C++ programs.

As an example, consider the class Pen below.

class Pen {

public:

Pen() {

cout << "Constructor..." <<endl;

~Pen() {

cout << "Destructor...!" <<endl;

void write(){

cout << "Writing...!" <<endl;

};

Below is an example, of how we create an object of the class Pen dynamically and delete it after we
are done with operations.

int main()

//create an object dynamically

Pen* pen = new Pen();

 pen->write();//operations

delete pen;//de-allocate the memory

return 0;

How to create an array of objects of a class in C?

Let’s see how we create an array of objects in the below C++ program example. In this example, we
will create an array of 3 objects, perform operations and delete a dynamic array of pointers properly.

int main()

//create an array of objects

Pen* pen = new Pen[3];

pen[0].write();

pen[1].write();

pen[2].write();

delete [] pen;//de-allocate array of objects

return 0;

Output:

Constructor…
Constructor…
Constructor…
Writing…!
Writing…!
Writing…!
Destructor…!
Destructor…!
Destructor…!

Proof of proper deletion of an array of objects in C++

First, note that if we create an object of a class and delete the object then class constructor and
destructor will be called respectively.

In the above example, we have created an array of 3 objects and deleted it using statement delete []
pen; if we look at the output the class constructor and destructor were called 3 times each. means,
we have deleted objects properly.

Now, If we delete the object using the statement “delete pen” ( This is a general mistake a
programmer makes) then the destructor will be called only once, and for the rest 2 objects
destructor will not be called and the program will crash. and this will prove that objects are not
deleted properly.

Let’s see the output if we use the statement “delete pen”

int main()

//create an array of objects

Pen* pen = new Pen[3];

pen[0].write();

pen[1].write();

pen[2].write();

//this is not a prper way to delete

//array of objects

delete pen;

return 0;

Output:

Constructor…
Constructor…
Constructor…
Writing…!
Writing…!
Writing…!
Destructor…!

and then the program will crash at run time.

Conclusion:
In C++, a single object of a class created dynamically is deleted using the statement “delete pointer”
and an array of objects are deleted using the statement “delete [ ] pointer”.

Ques 36: How many ways are there to initialize an int with a Constant?

Ans.

There are two ways:

• The first format uses traditional C notation.

int result = 10;

• The second format uses the constructor notation.

int result (10);

Ques 37: Explain The Is-a And Has-a Class Relationships. How Would You Implement Each In A
Class Design?

Ans.

A specialized class “is” a specialization of another class and therefore shares an IS-A relationship with
it. An ISA person who works for the business. Inheritance is the only way to implement this
partnership. The word “employee” comes from the word “person.” A class can contain an instance of
another class. Employees, for example, “have” salaries, because the Employee class has a HAS-A
relationship with the Wage class. The best way to enforce this relationship is to embed a Salary class
object in the Employee class.

Ques 38: Draw a comparison between C++ and Java

Ans.

Feature C++ Java

Syntax and C++ is a multi-paradigm language. It supports both Java is primarily an object-orie
Language procedural and object-oriented programming (OOP) It enforces strong OOP princip
Paradigm paradigms. Additionally, it allows low-level memory syntax is simpler and more con
manipulation through pointers. C++. It lacks features like point
safer in terms of memory man

Memory C++ offers manual memory management through Java provides automatic mem
Management pointers and explicit memory allocation/deallocation through the Java Virtual Mach
using new and delete. This level of control can lead garbage collector. Developers
to memory leaks and segmentation faults if not used manually allocate or deallocat
correctly. reducing the risk of memory-r

Platform C++ code must be recompiled for each target Java follows the “Write Once,
Independence platform, making it platform-dependent by default. principle. It compiles code into
independent bytecode, which
device with a compatible JVM
 Feature C++ Java

Performance C++ is often considered faster and more efficient for Java is generally slower than C
certain tasks because it allows for low-level memory good performance for most ap
manipulation and direct hardware access. improved over time with Just-
compilation and runtime optim

Community and C++ has a long history and a mature ecosystem with Java also has a robust ecosyste
Ecosystem numerous libraries and tools. used in enterprise software de
Android app development.

C++ Coding Questions and Answers

Ques 39: When there are a Global variable and Local variable with the same name, how will you
access the global variable?

Ans.

When two variables have the same name but different scopes, for example, one is a local variable
and the other is a global variable, the compiler would favor the local variable.

We use a “scope resolution operator (::)” to get access to the global variable. We can get the value of
the global variable with this operator.

Example:

#include<iostream>

int x= 10;

int main()

int x= 2;

cout<<”Global Variable x = “<<::x;

cout<<”\nlocal Variable x= “<<x;

Output:

Global Variable x = 10
local Variable x= 2

Ques 40: Why do we need the Friend class and function?

Ans.

It’s often necessary to grant specific class access to a class’s private or protected members. A friend
class is a solution since it can access both protected and private members of the class in which it is
declared as a friend. A friend feature, like the friend class, has access to private and safe class
members.

Friendship is not something you inherit.

• Friendship is not reciprocal, because if one class is a friend of another, such as NotAFriend, it
does not immediately become a friend of the Friend class.

• The total number of friend classes and friend functions in a program should be restricted
because too many of them will degrade the principle of encapsulation of separate classes,
which is an intrinsic and desirable quality of object-oriented programming.

Ques 41: What does the term “copy constructor” mean?

Ans. A copy constructor is like a special function in a class that helps create a new object by copying
the values from another object of the same kind.

Example-

class A{

int x,y;

A(int x, int y){

this->x=x;

this->y=y;

};

int main(){

A a1(2,3);

A a2=a1; //default copy constructor is called

return 0;

You have the option to make your own copy constructor. If you don’t, the system will automatically
use a default one.

Ques 42: What are void pointers?

Ans.

A void pointer, often denoted as void*, is a special type of pointer in programming that can point to
any data type. It’s like a universal pointer that doesn’t have a fixed data type. You can use it to point
to different types of data, but you need to be careful when you want to access or use the data it
points to because the compiler doesn’t know the actual data type.

#include <iostream>
int main() {

int num = 10;

float decimal = 3.14;

char letter = 'A';

void* ptr;

// Point the void pointer to different data types

ptr = #

std::cout << "Integer value: " << *static_cast<int*>(ptr) << std::endl;

ptr = &decimal;

std::cout << "Float value: " << *static_cast<float*>(ptr) << std::endl;

ptr = &letter;

std::cout << "Character value: " << *static_cast<char*>(ptr) << std::endl;

return 0;

In this example, we still use a `void*` pointer to point to different data types and cast it using
`static_cast` when accessing the data. This code achieves the same result as the previous C example
but with a more concise C++ syntax.

Ques 43: What is an abstraction in C++?

Ans.

In C++, abstraction is a concept that involves simplifying complex systems by hiding unnecessary
details. It lets you create user-defined data types (classes) to represent real-world entities, focusing
on what they do while hiding how they work. This is done by encapsulating data and providing
controlled access, promoting code organization and reusability.

Ques 44: What is operator overloading in C++? Provide an example.

Ans.
Operator overloading in C++ allows you to define how existing operators work with user-defined data
types (classes and objects). It enables you to create custom behavior for operators when applied to
objects of your classes.

Here’s a simple example of operator overloading using the + operator for a custom Complex class
representing complex numbers:

#include<iostream>

class Complex {

public:

double real;

double imaginary;

Complex() : real(0.0), imaginary(0.0) {}

Complex(double r, double i) : real(r), imaginary(i) {}

Complex operator+(const Complex& other) {

Complex result;

result.real = real + other.real;

result.imaginary = imaginary + other.imaginary;

return result;

};

int main() {

Complex num1(2.0, 3.0);

Complex num2(1.5, 2.5);

Complex sum = num1 + num2;

std::cout << "Sum: " << sum.real << " + " << sum.imaginary << "i" << std::endl;
 return 0;

In this example, operator overloading is used to redefine the + operator for a custom Complex class
to perform complex number addition.

Ques 45: Explain the concept of static and dynamic binding in C++.

Static Binding (Compile-time Binding):

• Decided at compile time.

• Based on the declared type.

• Used for non-virtual functions.

• Faster but less flexible.

Dynamic Binding (Runtime Binding):

• Decided at runtime.

• Based on the actual (dynamic) type.

• Used with virtual functions.

• Allows polymorphism but slower due to runtime lookup.

Ques 46: What is the diamond problem in C++? How is it resolved using virtual inheritance?

Ans.

The diamond problem in C++ is an issue that arises in multiple inheritance when a class inherits from
two or more classes that have a common base class. This results in ambiguity when trying to access
members of the common base class through the derived class.

It is resolved using virtual inheritance by making sure that there’s only one instance of the common
base class shared among the derived classes. This eliminates ambiguity by ensuring that the common
base class is not duplicated in the inheritance hierarchy. It’s achieved by declaring the common base
class as a virtual base class when inheriting from it. This way, the common base class is inherited only
once, and the diamond problem is resolved.

Ques 47: What is the “Big Three” in C++?

Ans.

The “Big Three” in C++ refers to three essential member functions when managing dynamic memory
and objects:

1. Destructor: Cleans up resources when an object is destroyed.

2. Copy Constructor: Creates a copy of an object.

3. Copy Assignment Operator: Assigns the values of one object to another.

They are crucial for proper resource management in classes.

Ques 48: Explain the differences between `public`, `protected`, and `private` access specifiers in
classes.

Ans.

The differences between the `public`, `protected`, and `private` access specifiers in C++ classes:

Access Accessibility within Accessibility in Accessibility Outside

Specifier the Class Derived Classes the Class

public Accessible Accessible Accessible

protected Accessible Accessible (for derived Not Accessible

classes)

Private Accessible Not Accessible . Not Accessible

Public Access Specifier: Members declared as public are accessible from anywhere. They can be
accessed within the class, by derived classes, and from outside the class.

Protected Access Specifier: Members declared as protected are accessible within the class and by
derived classes. They are not directly accessible from outside the class unless accessed through a
friend function or a public/protected member function of the class.

Private Access Specifier: Members declared as private are accessible only within the class. They are
not accessible from derived classes or outside the class.

Ques 49: Explain the concept of RAII (Resource Acquisition Is Initialization) in C++.

Ans.

RAII (Resource Acquisition Is Initialization) in C++ means tying resource management to the lifetime
of an object. Resources are acquired in the object’s constructor and released in its destructor. It
simplifies code, ensures automatic resource cleanup, and provides better exception safety.

Ques 50: How does the `volatile` keyword affect variable access in C++?

Ans.

The `volatile` keyword in C++ tells the compiler not to optimize access to a variable, ensuring that
reads and writes to it are always performed, which is useful for variables that can change
unexpectedly, like in multithreaded or embedded systems.