Sample Code

using namespace std;
 
class base {
public:
    virtual void print()
    {
        cout << "print base class\n";
    }
 
    void show()
    {
        cout << "show base class\n";
    }
};
 
class derived : public base {
public:
    void print()
    {
        cout << "print derived class\n";
    }
 
    void show()
    {
        cout << "show derived class\n";
    }
};
 
int main()
{
    base *bptr;
    derived d;
    bptr = &d;
 
    // Virtual function, binded at runtime
    bptr->print();
 
    // Non-virtual function, binded at compile time
    bptr->show();
   
    return 0;
}

Output

Syntax

             try {
  // Block of code to try
  throw exception; // Throw an exception when a problem arise
}
catch () {
  // Block of code to handle errors
} 

Sample Code

try {
  int age = 15;
  if (age >= 18) {
    cout << "Access granted - you are old enough.";
  } else {
    throw (age);
  }
}
catch (int myNum) {
  cout << "Access denied - You must be at least 18 years old.\n";
  cout << "Age is: " << myNum;
}

Output

Syntax

namespace namespace_name  
{  
     //body of namespace;  
}  

Syntax of accessing the namespace variable

namespace_name::member_name; 

Sample code

 using namespace std;  
namespace addition  
{  
    int a=5;  
    int b=5;  
    int add()  
    {  
        return(a+b);  
    }  
}  
  
int main() {  
int result;  
result=addition::add();  
cout<<result;  
return 0;  
      }  

Output

• For example, we consider four classes A, B, C, and D.
• If an object of type D tries to access members of A, ambiguity arises as to which class it should resolve.
• If it is class D that C inherited or it is class D that B inherited as a result, compiler throws an error.
• We declare that B and C inherit A virtually, to remove this ambiguity.
• It ensures that an object of type D will contain only set of member variables from A.

Sample Code

using namespace std;
 
class A {
public:
    int x = 2;
};
 
class B: public virtual A {
};
 
class C: public virtual A {
};
 
class D: public B, public C {
};
 
int main() {
    D d = D();
    cout << "x : " << d.x << endl;
}

Output

]]> https://www.wikitechy.com/interview-questions/cpp/what-is-virtual-inheritance/feed/ 0 https://www.wikitechy.com/interview-questions/cpp/what-is-template-in-c/ https://www.wikitechy.com/interview-questions/cpp/what-is-template-in-c/#respond Fri, 19 Aug 2022 11:54:35 +0000 https://www.wikitechy.com/interview-questions/?p=4805

Function Template

• Generic functions use the concept of function template and it defines a set of operations that can be applied to the various types of data.
• The function will operate on depends on the type of the data passed as a parameter.
• It can be implemented to an array of floats or array of integers, quick sorting algorithm is implemented using a generic function.
• Using keyword template generic function is created and template defines what function will do.

Sample Code

#include <iostream>  
using namespace std;  
template<class T> T add(T &a,T &b)  
{  
    T result = a+b;  
    return result;  
      
}  
int main()  
{  
  int i =2;  
  int j =3;  
  float m = 2.3;  
  float n = 1.2;  
  cout<<"Addition of i and j is :"<<add(i,j);  
  cout<<'\n';  
  cout<<"Addition of m and n is :"<<add(m,n);  
  return 0;  
}  

Output

Class Template

• Class template is also similar to function template.
• If class uses the concept of template, then the class is known as generic class.
• In class template Ttype is a placeholder name which will be determined when the class is instantiated.
• We can define one or more than generic data type using a comma-separated list. It can be used inside the class body.

Sample Code

#include <iostream>  

using namespace std;  

template<class T>  

class A   

{  

    public:  

    T num1 = 5;  

    T num2 = 6;  

    void add()  

    {  

        std::cout << "Addition of num1 and num2 : " << num1+num2<<std::endl;  

    }  

      

};  

  

int main()  

{  

    A<int> d;  

    d.add();  

    return 0;  

}  

Output

]]> https://www.wikitechy.com/interview-questions/cpp/what-is-template-in-c/feed/ 0 https://www.wikitechy.com/interview-questions/cpp/what-is-stack-in-c/ https://www.wikitechy.com/interview-questions/cpp/what-is-stack-in-c/#respond Fri, 19 Aug 2022 10:51:23 +0000 https://www.wikitechy.com/interview-questions/?p=4801

Syntax

template <class Type, class Container = deque<Type> > class stack;

Sample Code

#include <iostream>  
#include <stack>  
using namespace std;  
void newstack(stack <int> ss)  
{  
    stack <int> sg = ss;  
    while (!sg.empty())  
    {  
        cout << '\t' << sg.top();  
        sg.pop();  
    }  
    cout << '\n';  
}  
int main ()  
{  
    stack <int> newst;  
    newst.push(55);  
    newst.push(44);  
    newst.push(33);  
    newst.push(22);  
    newst.push(11);  
  
    cout << "The stack newst is : ";  
    newstack(newst);  
    cout << "\n newst.size() : " << newst.size();  
    cout << "\n newst.top() : " << newst.top();  
    cout << "\n newst.pop() : ";  
    newst.pop();  
    newstack(newst);   
    return 0;  
}  

Output

Syntax

datatype *var_name; 
int *ptr;

Sample Code

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

Output

Operator Overloading

• Operator overloading is otherwise known as compile-time polymorphism in which a standard operator is overloaded to provide a user-defined definition to it.
• ‘+’ operator is overloaded to perform the addition operation on data types such as float, int, etc.
• In following functions operator overloading can be implemented such as Member function, Non-Member function, Friend Function.

Sample Code

using namespace std;    
class Test    
{    
   private:    
      int num;    
   public:    
       Test(): num(8){}    
       void operator ++()         {     
          num = num+2;     
       }    
       void Print() {     
           cout<<"The Count is: "<<num;     
       }    
};    
int main()    
{    
    Test tt;    
    ++tt;  // calling of a function "void operator ++()"    
    tt.Print();    
    return 0;    
}  

Output

Function Overloading

• Function overloading is a type of compile-time polymorphism which can define a family of functions with the same name.
• The function would perform different operations based on the argument list in the function call.
• In argument list function to be invoked depends on the number of arguments and the type of the arguments.

Sample Code

using namespace std;    
class Cal {    
    public:    
static int add(int a,int b){      
        return a + b;      
    }      
static int add(int a, int b, int c)      
    {      
        return a + b + c;      
    }      
};     
int main(void) {    
    Cal C;                                                    //     class object declaration.   
    cout<<C.add(10, 20)<<endl;      
    cout<<C.add(12, 20, 23);     
   return 0;    
}    

Output

• In numerical expression a boolean variable in C++ can be used as well.
• if a bool variable is equal to true (or any numeric value other than 0), 1is assigned to it and taken as 1 during the evaluation of the expression; 0 and false will be taken as 0.

Sample Code

#include <iostream>
using namespace std;

int main() {
  bool x = 10;  // x = 1;
  bool y = false;  // y = 0;

  // Using bool in a numeric expression:
  cout << 2 * (x + y) << endl;
  
  return 0;
}

Output

Sample Code

using namespace std;  
class Base  
{  
    public:  
    Base() // Constructor member function.    
{  
    cout << "\n Constructor Base class";  // It prints first.  
}  
 virtual ~Base() // Define the virtual destructor function to call the Destructor Derived function.  
{  
    cout << "\n Destructor Base class";  /  
}  
};  
// Inheritance concept  
class Derived: public Base   
{  
    public:  
    Derived() // Constructor function.  
{  
    cout << "\n Constructor Derived class" ; /* After print the Constructor Base, now it will prints. */  
}  
 ~Derived() // Destructor function   
{  
    cout << "\n Destructor Derived class"; /* The virtual Base Class? Destructor calls it before calling the Base Class Destructor. */  
}         
};  
int main()  
{  
    Base *bptr = new Derived; // A pointer object reference the Base class.  
    delete bptr; // Delete the pointer object.  
}  

Output

Input iterator

• They have limited functionality and weakest of all iterators.
• In single-pass algorithms it can be used.
• Those algorithms which process the container sequentially, such that no element is accessed more than once.

Output iterator

• It is also like input operators, they are also very limited in their functionality and can only be used in single-pass algorithm, but not for accessing elements, but for being assigned elements.

Forward iterator

• It is higher in hierarchy than input iterator and output iterator and contain all the features present in these two iterators
• As name suggests, they can also only move in a forward direction and that too one step at a time.

Bidirectional iterator

• It has all the features of forward iterators along with the fact that they overcome the drawback of forward iterators, in both the directions they can move, hence their name is Bidirectional iterators.

Random Access iterator

• It is the most powerful iterators and they are not limited to moving sequentially, as their name suggests, they can randomly access any element inside the container.

Sample Code

#include <iostream>

    #include <vector>

    using namespace std;

    int main()

    {

            // Declaring a vector

            vector<int> v = { 1, 2, 3 };




           // Declaring an iterator

           vector<int>::iterator i;




           int j;




           cout << "Without iterators = ";

     

           // Accessing the elements without using iterators

           for (j = 0; j < 3; ++j)

        {

          cout << v[j] << " ";

        }




          cout << "\nWith iterators = ";

     

          // Accessing the elements using iterators

         for (i = v.begin(); i != v.end(); ++i)

      {

          cout << *i << " ";

      }




         // Adding one more element to vector

         v.push_back(4);




         cout << "\nWithout iterators = ";

     

         // Accessing the elements without using iterators

        for (j = 0; j < 4; ++j)

     {

         cout << v[j] << " ";

     }




         cout << "\nWith iterators = ";

     

        // Accessing the elements using iterators

       for (i = v.begin(); i != v.end(); ++i)

    {

        cout << *i << " ";

    }




    return 0;

  }

Output

Sample Code

#include<iostream>
               using namespace std;
              class Demo {
                   private:
                   int num1, num2;
                   public:
                   	Demo(int n1, int n2) {
                                   cout<<"Inside Constructor"<<endl;
                                   num1 = n1;
                                   num2 = n2;
                              }
                             void display() {
                                   cout<<"num1 = "<< num1 <<endl;
                                   cout<<"num2 = "<< num2 <<endl;
                             }
                         ~Demo() {
                                  cout<<"Inside Destructor";
                            }
                       };
                      int main() {
                      Demo obj1(30, 50);
                      obj1.display();
                      return 0;
                      }

Output

Default Constructor

• It is the constructor which has no parameters and doesn’t take any argument.

Sample Code

using namespace std;

class construct

{

public:

    int a, b;




    // Default Constructor

    construct()

    {

        a = 30;

        b = 40;

    }

};




int main()

{

    // Default constructor called automatically

    // when the object is created

    construct c;

    cout << "a: " << c.a << endl

         << "b: " << c.b;

    return 1;

}

Output

Parameterized Constructor

• It is possible to pass arguments to constructors and these arguments help initialize an object when it is created typically.

Sample Code

using namespace std;

class Point

{

private:

    int x, y;




public:

    // Parameterized Constructor

    Point(int x1, int y1)

    {

        x = x1;

        y = y1;

    }




    int getX()

    {

        return x;

    }

    int getY()

    {

        return y;

    }

};




int main()

{

    // Constructor called

    Point p1(10, 15);




    // Access values assigned by constructor

    cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();




    return 0;

}

 Output

Copy Constructor

• It is a member function which initializes an object using another object of the same class.

Sample Code

using namespace std;

class point

{

private:

  double x, y;




public:

   

  // Non-default Constructor &

  // default Constructor

  point (double px, double py)

  {

    x = px, y = py;

  }

};




int main(void)

{




  // Define an array of size

  // 10 & of type point

  // This line will cause error

  point a[10];




  // Remove above line and program

  // will compile without error

  point b = point(5, 6);

}

Output

• C++ gives a clear structure to programs and allows code to be reused, lowering development costs because it is an Object-Oriented Programming language.
• C++ is close to Java and C#, it makes easy for programmers to switch vice versa or C++.
• It is used to develop browsers, games, operating systems and so on.

Sample Code

#include <iostream>
using namespace std;

int main() 
{
  cout << "Welcome to Wikitechy";
  return 0;
}

Output

Compile-time polymorphism

• At compile time which is implemented known as Compile-time polymorphism. It is otherwise known as static polymorphism.
• Method overloading is also an example for compile-time polymorphism.
• Method overloading which allows you to have more than one function with the same function name but with different functionality.

Sample Code

using namespace std;  

class Multiply  

{  

   public:  

   int mul(int a,int b)  

   {  

       return(a*b);  

   }  

   int mul(int a,int b,int c)  

   {  

       return(a*b*c);  

  }  

 };  

int main()  

{  

    Multiply multi;  

    int res1,res2;  

    res1=multi.mul(2,3);  

    res2=multi.mul(2,3,4);  

    cout<<"\n";  

    cout<<res1;  

    cout<<"\n";  

    cout<<res2;  

    return 0;  

}  

Output

Run-time polymorphism

• Run-time polymorphism is otherwise known as dynamic polymorphism.
• Function overriding is an example of runtime polymorphism that means when the child class contains the method which is already present in the parent class.
• In function overriding, parent and child class both contains the same function with the different definition.
• The call to the function is determined at runtime is known as runtime polymorphism.

Sample Code

using namespace std;  

class Base  

{ 

    public:  

    virtual void show()  

    {  

        cout<<"Wikitechy";  

     }  

};  

class Derived:public Base  

{  

    public:  

    void show()  

    {  

        cout<<"Welcome to Wikitechy";  

    }  

};  

  

int main()  

{  

    Base* b;  

    Derived d;  

    b=&d;  

    b->show();  

                return 0;  

}  

Output

Private

• The private modifier is only within the class and it cannot be accessed from outside the class.

Sample Code

class A{  

private int data=40;  

private void msg(){System.out.println("Welcome to Wikitechy");}  

}  

  

public class Simple{  

 public static void main(String args[]){  

   A obj=new A();  

   System.out.println(obj.data);//Compile Time Error  

   obj.msg();//Compile Time Error  

   }  

}  

Output

Public

• The public modifier is everywhere, and it can access from within the class, outside the class, within the package and outside the package.

Sample Code

package pack;  

public class A{  

public void msg(){System.out.println("Welcome to Wikitechy");}  

}  

Output

Protected

• The protected modifier is within the package and outside the package through child class.
• It cannot be accessed from outside the package, if you do not make the child class.

Sample Code

package pack;  

public class A{  

protected void msg(){
System.out.println("Welcome to Wikitechy");
}  

}  

Output

Default

• The default modifier is only within the package and it cannot be accessed from outside the package.
• It will be the default, if you do not specify any access level.

Sample Code

package pack;  

class A{  

  void msg(){System.out.println("Welcome to Wikitechy");}  

} 

Output

Advantages of C++

Portability

• Portability or platform independence which allows the user to run the same program on different interfaces or operating system.
• For programmer this feature proves to be of great convenience.
• Suppose in Linux OS we write a program and for some reason switch to Windows OS, we would be able to run the same program in windows as well without any error.

Object-Oriented

• In C++ the feature of object-oriented programming which includes concepts like classes, polymorphism, inheritance, encapsulation and data abstraction that makes a program even more reliable and allow code reusability.

Multi-Paradigm

• It is a multi-paradigm programming language.
• The term paradigm refers to the style of programming and includes procedure, logic and structure.
• Generic, object-oriented and imperative are the three paradigms of C++.

Memory Management

• C++ programmer gives the provision of total control over memory management.
• An asset and a liability are the both increases the responsibility of the user to manage memory rather than it being managed by Garbage Collector.

Compatibility with C

• Compare with C program, C++ is pretty much compatibility
• Every error-free C program is a valid of C++ program, virtually.
• Every program of C++ can run on a file with .cpp extension, depending on the compiler used.

Low-Level Manipulation

• At certain level C++ allows low-level manipulation of data, which is a procedural language closely related to the machine language, C++ is closely associated with C.
• Compiler and embedded systems are created with the help of C++.

Large Community Support

• C++ has a large community that supports it by providing online courses and both paid, unpaid and lectures.
• Statistically speaking, in Stack Overflow and Git Hub C++ is the most used and followed tag.

Scalability

• Scalability refers to the ability of a program to scale, that means the C++ program is capable of running on a small scale as well as a large scale of data.

Disadvantages of C++

Use of pointers

• Pointers in C++ consumes a lot of memory and relatively difficult concept to grasp.
• Misuse of pointers like wild pointers may cause the system to behave or crash anomalously.

Absence of garbage collector

• Using Dynamic Memory Allocation (DMA) C++ gives the user complete control of managing the computer memory.
• It lacks the feature of a garbage collector to automatically filter out unnecessary data.

Security Issues

• As compared to other programming languages object-oriented programming offers a lot of security to the data being handled that are not object-oriented, like C, certain security issues still exist due to the availability of pointers, friend functions and global variables.

Absence of built-in thread

• Threads is a relatively new concept in C++ which wasn’t initially there and it does not support any built-in threads.

               Structure   

                    Class Structure is a collection of different types of data type Class is a group of common objects that share common properties and relationships. By default, structure member is public By default, class member is private Structure is value type so they are stored on stack Class is reference type so they are stored on heap It cannot be inherited It can be inherited Structure should be used when you want to use a small data structure Class is better choice for complex data structure Structure elements cannot be declared as protected Class elements can be declared as protected GC does not call finalize method for them because structure are not terminated GC does call finalize method for them because class are terminated Structure does not require constructor Class does require constructor The member variable of structure cannot be initialized directly The member variable of class can be initialized directly It can only have parameterized constructor It can have all types of constructor and destructor

]]> https://www.wikitechy.com/interview-questions/cpp/difference-between-c-and-cpp/feed/ 0 https://www.wikitechy.com/interview-questions/cpp/print-pyramid-triangle-in-cpp/ https://www.wikitechy.com/interview-questions/cpp/print-pyramid-triangle-in-cpp/#respond Tue, 13 Jul 2021 00:20:02 +0000 https://www.wikitechy.com/interview-questions/?p=406

#include <iostream>
using namespace std;
   int main()
{
    int j, rows;
       cout <<"Enter number of rows: ";
    cin >> rows;
       for(int i = 1, k = 0; i <= rows; ++i, k = 0)
    {
        for(j = 1; j <= rows-i; ++j)
        {
            cout <<"  ";
        }
        while(k != 2*i-1)
        {
            cout << "* ";
            ++k;
        }
        cout << endl;
    }    
    return 0;
}

Enter number of rows : 7   
            * 
          * * * 
        * * * * * 
      * * * * * * * 
    * * * * * * * * * 
  * * * * * * * * * * * 
* * * * * * * * * * * * *