Tech Mahindra Interview Preparation and Recruitment Process

Inline Functions in C++ and C

What is an inline function?

• An inline function is a function where the function call is replaced with the function code itself during compile time.

• Instead of performing a regular function call (which involves overhead like pushing arguments onto the stack), the compiler inserts the actual code at the place where the function is called.

• Purpose: To reduce the overhead of function calls, making execution faster, especially for small, frequently called functions.

Inline Function in C++

In C++, you explicitly use the inline keyword when defining a function:

#include <iostream>
using namespace std;

// Inline function
inline int add(int a, int b) {
    return a + b;
}

int main() {
    cout << "Sum = " << add(5, 10) << endl;
    return 0;
}

* Explanation:

• When you call add(5, 10), the compiler replaces it directly with 5 + 10 during compilation.

Inline Function in C

In C, inline functions were introduced in C99 standard.
Before C99, C didn't officially support inline, but now you can use it like this:

#include <stdio.h>

// Inline function
inline int multiply(int a, int b) {
    return a * b;
}

int main() {
    int result = multiply(4, 5);
    printf("Product = %d\n", result);
    return 0;
}

* Explanation:

• Here, multiply(4, 5) will be replaced at compile time with the multiplication logic 4 * 5, avoiding a real function call.

Important Points

Note:

• Inline is just a request to the compiler; the compiler may ignore it if it thinks it's not efficient to inline.

• Large functions are usually not inlined because it would increase the size of the binary (code bloat).

The world of object lifecycle in C++! Destructors are special member functions in C++ classes that play a crucial role in cleaning up resources when an object is no longer needed. Think of constructors as the "birth" of an object, and destructors as its "farewell."

Here's a breakdown of what makes destructors important:

Purpose of C++ Destructors:

• Resource Deallocation: The primary job of a destructor is to release any resources that the object acquired during its lifetime. This can include:
  • Dynamically allocated memory (using new).
  • Open files.
  • Network connections.
  • Acquired locks or handles to system resources.
• Performing Cleanup Operations: Beyond deallocation, destructors can execute any other necessary cleanup tasks before an object is destroyed. This might involve saving state, logging information, or notifying other objects.
• Automatic Invocation: Unlike regular member functions that you need to call explicitly, destructors are automatically called by the compiler in the following situations:
  • When a local object goes out of scope.
  • When a dynamically allocated object is deleted using the delete operator.
  • When a temporary object's lifetime ends.
  • During stack unwinding in exception handling.

Key Characteristics of Destructors:

• Name: A destructor has the same name as the class, but it is preceded by a tilde (~). For a class named MyClass, the destructor would be named ~MyClass().
• No Arguments: Destructors cannot take any arguments (parameters).
• No Return Type: Destructors do not have a return type, not even void.
• Uniqueness: A class can have only one destructor.
• Virtual Destructors (Important for Inheritance): In inheritance hierarchies, especially when you delete a derived class object through a base class pointer, it's crucial to declare the base class's destructor as virtual. This ensures that the correct destructor (the derived class's destructor) is called, preventing potential resource leaks and undefined behavior.

C++ Syntax for a Destructor:

class MyClass {
public:
    // Constructor (optional)
    MyClass() {
        // Initialization code
    }

    // ... other member variables and functions ...

    // Destructor
    ~MyClass() {
        // Cleanup code goes here
        // For example:
        // delete somePointer;
        // close(fileDescriptor);
        // ...
    }
};

Example Illustrating Destructor Usage:

#include <iostream>

class MyResource {
private:
    int* data;

public:
    MyResource() {
        std::cout << "Constructor called for MyResource." << std::endl;
        data = new int[10]; // Allocate some dynamic memory
    }

    ~MyResource() {
        std::cout << "Destructor called for MyResource." << std::endl;
        delete[] data;      // Release the dynamically allocated memory
        data = nullptr;
    }

    void setValue(int index, int value) {
        if (index >= 0 && index < 10) {
            data[index] = value;
        }
    }

    int getValue(int index) const {
        if (index >= 0 && index < 10) {
            return data[index];
        }
        return -1; // Indicate an error
    }
};

int main() {
    {
        std::cout << "Entering inner scope." << std::endl;
        MyResource obj1; // Constructor is called when obj1 is created
        obj1.setValue(0, 100);
        std::cout << "Value in obj1: " << obj1.getValue(0) << std::endl;
    } // Destructor for obj1 is automatically called when it goes out of scope
    std::cout << "Exiting inner scope." << std::endl;

    MyResource* obj2 = new MyResource(); // Constructor is called
    obj2->setValue(1, 200);
    std::cout << "Value in obj2: " << obj2->getValue(1) << std::endl;
    delete obj2; // Destructor for obj2 is explicitly called using delete
    obj2 = nullptr;

    return 0;
}

Output of the Example:

Entering inner scope.
Constructor called for MyResource.
Value in obj1: 100
Destructor called for MyResource.
Exiting inner scope.
Constructor called for MyResource.
Value in obj2: 200
Destructor called for MyResource.

As you can see from the output, the destructors are automatically invoked when the MyResource objects go out of scope or are explicitly deleted using delete. This ensures that the dynamically allocated memory is properly released, preventing memory leaks.

void memoryLeak() {
int* ptr = new int(10); // Allocating memory
// No delete statement, leading to a memory leak
}​

#include<bits/stdc++.h>
using namespace std;
int evenOddDiff(int n, vector<int> &a)
{
   int oddSum = 0,evenSum = 0;
   for(int i: a)
   {
       if(i & 1)
           oddSum += i;
       else
           evenSum += i;
   }
   return evenSum - oddSum;
}
int main()
{
   int n;
   cin>>n;
   vector<int> a(n);
   for(int j = 0; j < n; j ++)cin >> a[j];
   cout << evenOddDiff(n, a) << endl;
   return 0;
}​

#include <bits/stdc++.h>
using namespace std;
void foo(int n) {
   cout << " Integer Value:  " << n << endl;
}
void foo(double n) {
   cout << " Decimal Value " << n << endl;
}
void foo(char n) {
   cout << " Character Value" << nc << endl;
}
int main() {
   foo(40);
   foo(452.144);
   foo("A");
   return 0;
}​

protected void finalize throws Throwable{}​

public class FinalizeMethodExample {  
    public static void main(String[] args)   
   {   
       FinalizeMethodExample o = new FinalizeMethodExample ();   
       System.out.println(o.hashCode());   
       o = null;   
       // a call to the garbage collector of Java   
       System.gc();   
       System.out.println("The end of garbage collection!");   
 
   }  
   @Override  
   protected void finalize()   
   {   
       System.out.println("The finalize method is being called now!");   
   }   
}​

3202429534
The end of garbage collection!
The finalize method is being called now!​

#include<bits/stdc++.h>
using namespace std;
int evenOddDiff(int n, vector<int> &a)
{
   int oddSum = 0,evenSum = 0;
   for(int i: a)
   {
       if(i & 1)
           oddSum += i;
       else
           evenSum += i;
   }
   return evenSum - oddSum;
}
int main()
{
   int n;
   cin>>n;
   vector<int> a(n);
   for(int j = 0; j < n; j ++)cin >> a[j];
   cout << evenOddDiff(n, a) << endl;
   return 0;
}​