DEV Community: Komal Singh

C++ Interview Questions

Komal Singh — Mon, 12 Oct 2020 13:24:24 +0000

What is a constructor
A constructor is a member function of a class that initializes objects of a class. In C++, Constructor is automatically called when an object(instance of a class) is created.
There are three types of constructors:

Default Constructor: Constructor with no parameters/arguments

#include <iostream> 
using namespace std; 
class A { 
public: 
    int a, b; 
    // Default Constructor 
    A() 
    { 
        a = 1; 
        b = 2; 
    } 
}; 

int main() 
{ 
    // Default constructor called automatically 
    // when the object is created 
    A obj; 
    cout << "a: " << obj.a << endl 
         << "b: " << obj.b; 
    return 1; 
}

Output:
a: 1
b: 2
The compiler automatically provides a default constructor even if we do not initialize one.

Parameterized Constructor: Constructor with Parameter/Arguments

#include <iostream>
using namespace std;
class ParamA {
private:
int b, c;
public:
ParamA (int b1, int c1)
{
b = b1;
c = c1;
}
int getX ()
{
return b;
}
int getY ()
{
return c;
}
};
int main ()
{
ParamA p1(10, 15);
cout << "p1.b = " << p1. getX() << ", p1.c = " << p1.getY();
return 0;
}

Output: p1.b = 10, p1.c = 15

Copy Constructor: A copy constructor is a member function that initializes an object using another object of the same class.

#include<iostream>
using namespace std;
class test
{
private:
int x;
public:
test(int x1)
{
x = x1;
}
test(const test &t2)
{
x = t2.x;
}
int getX()
{
return x;
}
};
int main()
{
test t1(7); // Normal constructor is called here
test t2 = t1; // Copy constructor is called here
cout << "t1.x = " << t1.getX();
cout << "t2.x = " << t2.getX();
return 0;
}

t1.x = 7
t2.x = 7

How constructors are different from a normal member function?

A constructor is different from normal functions in the following ways:

A constructor has the same name as the class name
Constructors don’t have a return type
A constructor is automatically called when an object is created.
If we do not specify a constructor, the C++ compiler generates a default constructor.

Constructor Overloading in C++
Two or more constructors in a class with the same name but a different list of arguments is known as Constructor Overloading.

A constructor is called depending upon the number and type of arguments passed. While creating the object, arguments must be passed to let the compiler know the constructor that is needed to be called.

What is a destructor?
Destructor is a member function that destructs or deletes an object.
A destructor function is called automatically when the object goes out of scope:
(1) the function ends
(2) the program ends
(3) a block containing local variables ends
(4) a delete operator is called

Destructors have the same name as the class preceded by a tilde (~)
Destructors don’t take any argument and don’t return anything.
NOTE
The compiler creates a default destructor for us if we do not write our own destructor in class. The default destructor works fine unless we have dynamically allocated memory or pointer in class. When a class contains a pointer to memory allocated in class, we should write a destructor to release memory before the class instance is destroyed. This must be done to avoid Memory Leak.

Part 1: Series of C++ interview Questions

Will be adding some more C++ based interview questions. Do suggest if you have come across some interesting C++ questions in interviews :)

C++ Common Interview Questions

Komal Singh — Tue, 06 Oct 2020 04:05:32 +0000

What is this keyword and its use?

A very common concept used frequently in C++ Code. Let's see what are the use and what it is.
Each object gets its own copy of data members and all objects share a single copy of member functions.
Then now question is that if only one copy of each member function exists and is used by multiple objects, how are the proper data members are accessed and updated?
The compiler supplies an implicit pointer along with the names of the functions as ‘this’.
The ‘this’ pointer is passed as a hidden argument to all nonstatic member function calls and is available as a local variable within the body of all nonstatic functions. ‘this’ pointer is not available in static member functions as static member functions can be called without any object (with class name).
The following are the uses of This Pointer:
1) When local variable’s name is same as member’s name
2) To return a reference to the calling object

(Answer Credits: GFG)

What are Serialization and Deserialization
Serialization is a mechanism to convert an object into a sequence of bytes so that it can be stored in memory. The byte stream, once created, also can be streamed across a communication link to a remote receiving end. The reverse of serialization is called deserialization, where the data in the byte stream is used to reconstruct it to its original object form. Apart from object persistence, this mechanism is particularly useful in transmitting object information in serialized form, say, to the server which, on receiving it, can deserialize and create the object format which is its original form.

What are virtual functions – Write an example?

Virtual functions are used with inheritance, they are called according to the type of the object pointed or referred, not according to the type of pointer or reference. In other words, virtual functions are resolved at runtime. Virtual keyword is used to make a function virtual.
Suppose we have the same function name in both the base and derive class and we want to access the derived class method, we can achieve this by making the base class method virtual.

For example, in the following program, bp is a pointer of type Base, but a call to bp->show() calls show() function of Derived class because bp points to an object of Derived class.

#include<iostream> 
using namespace std; 

class Base { 
public: 
    virtual void show() { cout<<" In Base \n"; } 
}; 

class Derived: public Base { 
public: 
    void show() { cout<<"In Derived \n"; }  
}; 

int main(void) {    
    Base *bp = new Derived;      
    bp->show();  // RUN-TIME POLYMORPHISM 
    return 0; 
}

O/P: In Derived

*What is Pure Virtual function? *

A pure virtual function (or abstract function) in C++ is a virtual function for which we don’t have an implementation, we only declare it. A pure virtual function is declared by assigning 0 in its declaration. See the following example.

class virtualexample 
{    
    // Data members of class 
public: 
    // Pure Virtual Function 
    virtual void show() = 0; 

   /* Other members */
};

Will be adding some more C++ based interview questions. Do suggest if you have come across some interesting C++ questions in interviews.

CI/CD and It's best Practices

Komal Singh — Tue, 01 Sep 2020 13:17:45 +0000

Continuous Integration, Delivery, and Deployment known collectively as CI/CD is a very common buzzword in IT Industry. It is an integral part of modern development intended to reduce errors during integration while increasing productivity.
So now we know that CI/CD is so important let's understand what it is:
CI (Continuous Integration)
This is a practice followed by the developers to merge their code changes in the master repository as often as possible.
The change is then validated by automated build and Test Cases. This avoids the integration blunder that usually happens when people wait for release day to merge their changes into the release branch.
Continuous integration puts a great emphasis on Automation testing to check that the application is not broken whenever new commits are integrated into the main branch.

Continuous Delivery
Continuous Delivery makes sure that the release can be made in Production after Testing. This means that Continuous delivery is not only about automated testing but also an automated release process that deploys your application at any point in time by clicking on a button.
If you truly want to get the benefits of continuous delivery, you should deploy to production as early as possible to make sure that you release small batches that are easy to troubleshoot in case of a problem.

Continuous Deployment
Continuous Deployment is a step ahead of Continuos delivery. With this practice, every change that passes all stages of the production pipeline is released to the customers. every step is automated and only a failed test will prevent a new change to be deployed to production.
The entire CI/CD process is a boon for business

So now we know that CI/CD can help the developers a lot and they can now focus on important agenda instead of bugging on release day. Successful implementation of CI/CD is required to get the best out of it and hence it is important to follow the best CI/CD practices.

Here are some of the mandatory practices to follow in CI/CD for the best result:

1. Securing and isolating the CI/CD environment

In this era where security threats can lead to a massive reputation and financial losses to businesses. Stressing on the importance of security is very important. Since the CI/CD system offers access to the codebase and credentials to deploy in various environments, it is often the prime target. Shielding all external access to the servers and tightly controlling the types of internal access allowed will help reduce the risk of your CI/CD system being compromised.

2. Commit daily and reduce branching in the Version Control

Committing changes daily can make integration with the master branch really easier. This can save a massive amount of time invested in Version Control.

3. Run Tests Locally Before Committing to the CI/CD Pipeline

Discovering failures early is an important criterion. Changes must be tested in the Dev environment thoroughly before finally committing to the PROD environment. The local developer environment should have the entire test cases as in the production environment.

To ensure that developers can test effectively on their own, the testing environment should be runnable with a single command that can be run from any environment. This is often achieved by providing a shell script or makefile to automate running the testing tools.

4. Keep the Pipelines Fast

CI/CD pipelines help changes through automated testing cycles, UAT environments, and finally to production. The testing Pipeline must be more comprehensive to avoid unforeseen situations in production deployment. Since all the change must go through this process, keeping the pipelines fast is incredibly important to not inhibit development speed.

Now how can we speed up the process in the Pipeline?
Steps that you can take to improve speed are scaling CI/CD infrastructure and optimizing tests.

Two broad categories of tests that can be automated are:

Tests that are executed on a frequent basis
If such tests are executed ‘manually’ by testers, it may be prone to errors since the productivity may reduce as the testers have to execute the same test multiple times in a day. Hence Automating these Test cases can definitely boost up the Deployment.

Tests that require knowledge & have the dependency on a specific set of testers
Dependency on a developers/testers that only have the domain knowledge required for test execution can be risky during a critical phase of the project. Their absence can impact the overall project deliverables. Such situations can be avoided by incorporating test automation in the CI/CD pipeline, so that project deadlines are not adversely affected

There could be many other scenarios where automation testing can be used and the intent should be to make use of tools & test platforms (which are scalable) that can help you to achieve the required goal.

5. Decide which processes and tests to automate first

In many projects that when it comes to testing automation for CI/CD pipeline, we often forget to prioritize our test case in a systematic approach. Here is what I mean! As a best practice of CI/CD, it is always recommended to execute your smaller and simple test cases before your long and complex ones.

This way you could be sure of individual test case coverage and performance with respect to functionality testing in an isolated manner. Complex test cases where you design test cases to check the interaction between multiple modules can come later!

PS: Hope this article is useful. Feel free to add Valuable points!