In this chapter we are going to study C++ Pointer Operators. C++ provides two pointer operators one is value at operator or indirection operator and address operator.

C++ Pointer Operator

C++ Address of Operator (&)

1. The & is a unary operator means it requires only one operand.
2. The Address of Operator returns the memory address of its operand.
3. Address of operator has the same precedence and right-to-left associativity as that of other unary operators.
4. Symbol for the bitwise AND and the address of operator are the same but they don’t have any connection between them

C++ Program : Address of Operator

#include<iostream>
using namespace std;

int main()
{
   int num=10;
	   
   cout << "Value of number   : " << num << endl;
   cout << "Address of number : " << &num << endl;
}

Output :

Value of number : 10
Address of number : 0xffad72dc

Summary

C++ Indirection Operator *

1. The Indirection operator * is a unary operator means it requires only one operand.
2. Indirection Operator (*) is the complement of Address of Operator (&).
3. Indirection Operator returns the value of the variable located at the address specified by its operand.

C++ Program : Indirection Operator

#include<iostream>
using namespace std;

int main()
{
   int num=10;
   int *ptr;
   
   ptr=&num;
	   
   cout << " num = " << num << endl;
   cout << " &num = " << &num << endl;
   cout << " ptr = " << ptr << endl;
   cout<< " *ptr = " << *ptr << endl;
}

Output :

num = 10
&num = 0xffcc2bd8
ptr = 0xffcc2bd8
*ptr = 10

Calculations:

// Sample Code for Dereferencing of Pointer

*(ptr) = value at (ptr)
       = value at (0xffcc2bd8) 
       = 10

//Address in ptr is nothing but address of num

Summary

Though multiplication symbol and the “Indirection Operator” symbol are the same still they don’t have any relationship between each other.

Both & and * have a higher precedence than all other arithmetic operators except the unary minus/plus, with which they share equal precedence.

Conditional Operator [?:] : Ternary Operator in C++

1. Conditional operators are also called as Ternary Operator.
2. They are represented by ?:
3. Ternary Operator takes on 3 Arguments.

Syntax of Ternary Operator:

Expression_1 ? Expression_2 : Expression_3

where

Explanation of syntax:

1. Expression_1 is a condition so it will return the result either True or False.
2. If result of expression_1 is True that is NON-ZERO, then Expression_2 is Executed.
3. If result of expression_1 is False that is ZERO, then Expression_3 is Executed.

Program 1#: Conditional Operator Program

Let us take the simple example of finding greater number from two given numbers using Conditional Operator.

#include<iostream>
using namespace std;

int main()
{
   int num1=10;
   int num2=20;
   
   num1>num2 ? cout << "num1 is greater than num2" : cout<< "num2 is greater than num1" ;
   
   return 0;
}

Output:

num2 is greater than num1

C++ sizeof Operator

• sizeof is a compile-time operator used to calculate the size of data type or variable.
• sizeof operator will return the size in integer format.
• sizeof is a keyword.
• sizeof operator can be nested.

Syntax of sizeof Operator:

sizeof(data type)

Data type include variables, constants, classes, structures, unions, or any other user defined data type.

Examples of sizeof operator:

Size of Data Types

#include <iostream>
using namespace std;
 
int main()
{
   cout << "Size of int : " << sizeof(int) << endl;
   cout << "Size of long int : " << sizeof(long int) << endl;
   cout << "Size of float : " << sizeof(float) << endl;
   cout << "Size of double : " << sizeof(double) << endl;
   cout << "Size of char : " << sizeof(char) << endl;
  
   return 0;
}

Output:

Size of int : 4
Size of long int : 4
Size of float : 4
Size of double : 8
Size of char : 1

Size of Variables:

#include <iostream>
using namespace std;
 
int main()
{
   int i;
   char c;
 
   cout << "Size of variable i : " << sizeof(i) << endl;
   cout << "Size of variable c : " << sizeof(c) << endl;
  
   return 0;
}

Output:

Size of variable i : 4
Size of variable c : 1

Size of Constant:

#include <iostream>
using namespace std;
 
int main()
{
   cout << "Size of integer constant: " << sizeof(10) << endl;
   cout << "Size of character constant : " << sizeof('a') << endl;
  
   return 0;
}

Output:

Size of integer constant: 4
Size of character constant : 1

Nested sizeof operator:

#include <iostream>
using namespace std;
 
int main()
{
   int num1,num2;
   cout << sizeof(num1*sizeof(num2));
     return 0;
}

Output:

4

In the previous chapter we have learnt about the C++ constructors and basic type of constructors. In this chapter we will be learning about C++ Destructor Basics

C++ Destructor Basics

1. Destructors are special member functions of the class required to free the memory of the object whenever it goes out of scope.
2. Destructors are parameterless functions.
3. Name of the Destructor should be exactly same as that of name of the class. But preceded by ‘~’ (tilde).
4. Destructors does not have any return type. Not even void.
5. The Destructor of class is automatically called when object goes out of scope.

C++ Destructor programs

C++ Destructor Program #1 : Simple Example

#include<iostream> 
using namespace std;
 
class Marks
{
public:
   int maths;
   int science;
   
   //constructor
   Marks() {
      cout << "Inside Constructor"<<endl;
      cout << "C++ Object created"<<endl;
   }
	
   //Destructor
   ~Marks() {
      cout << "Inside Destructor"<<endl;
      cout << "C++ Object destructed"<<endl;
   }
};

int main( )
{
   Marks m1;
   Marks m2;
   return 0;
}

Output

Inside Constructor
C++ Object created
Inside Constructor
C++ Object created

Inside Destructor
C++ Object destructed
Inside Destructor
C++ Object destructed

Explanation :

You can see destructor gets called just before the return statement of main function. You can see destructor code below –

~Marks() {
   cout << "Inside Destructor"<<endl;
   cout << "C++ Object destructed"<<endl;
}

C++ Destructor always have same name as that of constructor but it just identified by tilde (~) symbol before constructor name.

Below example will show you how C++ destructor gets called just before C++ object goes out of scope.

C++ Destructor Program #2 : Out of scope

#include<iostream> 
using namespace std;
 
class Marks
{
public:
   int maths;
   int science;
   
   //constructor
   Marks() {
      cout << "Inside Constructor"<<endl;
      cout << "C++ Object created"<<endl;
   }
	
   //Destructor
   ~Marks() {
      cout << "Inside Destructor"<<endl;
      cout << "C++ Object destructed"<<endl;
   }
};

int main( )
{
   {
   Marks m1;
   }

   cout<<"Hello World !!" <<endl;
   cout<<"Hello World !!" <<endl;
   cout<<"Hello World !!" <<endl;
   cout<<"Hello World !!" <<endl;

   return 0;
}

Output :

Inside Constructor
C++ Object created
Inside Destructor
C++ Object destructed

Hello World !!
Hello World !!
Hello World !!
Hello World !!

Explanation :

In this example we have defined the scope of the object as we declared object inside the curly braces i.e inside the inner block.

int main( )
{
   {
   Marks m1;
   }

So object will be accessible only inside the curly block. Outside the curly block we cannot access the object so destructor gets called when inner curly block ends

In this example Hello World !! gets printed after the destructor. however for below example Hello World !! gets printed before constructor

C++ Destructor Program #3 : before destructor

#include<iostream> 
using namespace std;
 
class Marks
{
public:
   int maths;
   int science;
   
   //constructor
   Marks() {
      cout << "Inside Constructor"<<endl;
      cout << "C++ Object created"<<endl;
   }
	
   //Destructor
   ~Marks() {
      cout << "Inside Destructor"<<endl;
      cout << "C++ Object destructed"<<endl;
   }
};

int main( )
{
   Marks m1;
   
   cout<<"Hello World !!" <<endl;
   cout<<"Hello World !!" <<endl;
   cout<<"Hello World !!" <<endl;
   cout<<"Hello World !!" <<endl;

   return 0;
}

Output :

Inside Constructor
C++ Object created

Hello World !!
Hello World !!
Hello World !!
Hello World !!

Inside Destructor
C++ Object destructed

In this section we are going to study C++ Bitwise operator, its importance and basic operating principle.

C++ Programming Bitwise Operators:

• In programming, unlike byte level operations, we may need to do bit level calculations by operating on the individual data bit.
• C++ gives us various bitwise operators for manipulation of bits.
• C++ Bitwise Operators operates on Integer and character data types only.
• C++ Bitwise Operators does not operates on float, double.
• There are 6 Bitwise Operators in C++.

List of Bitwise Operators

Examples of Bitwise Operators:

One's Compliment (~) Operator:

This operator is generally used to turn ON or turn OFF bit.

#include <iostream>
using namespace std;

int main()
{
   // 12 = 0000 1100
   unsigned int num1 = 12
   int num2 = 0;           

   num2 = ~num1;  
   cout << "Value of num2 is: " << num2 << endl ;

   return 0;
}

Output:

Value of num2 is: -13

Right Shift (>>) Operator:

This operator is used to shift the bits to right by position specified in the expression.

#include <iostream>
using namespace std;

int main()
{
   unsigned int num1 = 12; // 12 = 1100 
   int num2 = 0;           

   num2 = num1 >> 2; // 3 = 0011
   cout << "Value of num2 is: " << num2 << endl ;

   return 0;
}

Output:

Value of num2 is: 3

Left Shift (<<) Operator:

This operator is used to shift the bits to left by position specified in the expression.

#include <iostream>
using namespace std;

int main()
{
   unsigned int num1 = 12; // 12 = 0000 1100 
   int num2 = 0;           

   num2 = num1 << 2; // 48 = 0011 0010
   cout << "Value of num2 is: " << num2 << endl ;

   return 0;
}

Output:

Value of num2 is: 48

Bitwise AND (&):

This operator is generally used to mask particular part of byte.

Output:

Value of num2 is: 8

#include <iostream>
using namespace std;

int main()
{
   unsigned int num1 = 10;	  // 10 = 0000 1010  
   unsigned int num2 = 12;	  // 12 = 0000 1100
   int num3 = 0;           

   num3 = num1 & num2;         // 8 = 0000 1000
   cout << "Value of num3 is : " << num3 << endl ;

   return 0;
}

Bitwise OR (|):

#include <iostream>
using namespace std;

int main()
{
   unsigned int num1 = 10;	  // 10 = 0000 1010  
   unsigned int num2 = 12;	  // 12 = 0000 1100
   int num3 = 0;           

   num3 = num1 | num2;         // 14 = 0000 1110
   cout << "Value of num3 is : " << num3 << endl ;

   return 0;
}

Output:

Value of num2 is: 14

Bitwise XOR (^):

#include <iostream>
using namespace std;

int main()
{
   unsigned int num1 = 10;  // 10 = 0000 1010  
   unsigned int num2 = 12;  // 12 = 0000 1100
   int num3 = 0;           

   num3 = num1 ^ num2;      // 6 = 0000 0110
   cout << "Value of num3 is : " << num3 << endl ;

   return 0;
}

Output:

Value of num2 is: 6

C++ assignment Operator basics

1. Assignment Operator is used to assign value to an variable.
2. Assignment Operator is denoted by equal to (=) sign.
3. This operator copies the value at the right side of the operator into the left side variable.
4. Assignment Operator is binary operator.
5. Assignment Operator has higher precedence than comma operator only.
6. Assignment Operator has lower precedence than all other operators except comma operator.

Ways of Using Assignment Operator:

In this section we are going to see different ways in which Assignment Operator can be used.

Assignment Operator used to Assign Value

In this case the particular value or result of particular expression is assigned to the variable.

#include<iostream>
using namespace std;

int main()
{
   int value;
   value=10;
   return 0;
}

In this example, 10 is assigned to variable value.

Assignment Operator used to Type Cast

#include<iostream>
using namespace std;

int main()
{
   int value;
   value=10.5;
   cout<<value;
   return 0;
}

Higher values can be type cast to lower values using assignment operator. It can also cast lower values to higher values.

Shorthand assignment operator:

#include <iostream>
using namespace std;

int main()
{
   int num = 10;
   num+=5 ;
   cout << "Result of Expression 1 = " <<num<< endl ;

   num = 10;
   num-=5 ;
   cout << "Result of Expression 2 = " <<num<< endl ;

   num = 10;
   num*=5 ;
   cout << "Result of Expression 3 = " <<num<< endl ;
   
   num = 10;
   num/=5 ;
   cout << "Result of Expression 4 = " <<num<< endl ;
   
   num = 10;
   num%=5 ;
   cout << "Result of Expression 5 = " <<num<< endl ;
   
   return 0;
}

Output:

Result of Expression 1 = 15
Result of Expression 2 = 5
Result of Expression 3 = 50
Result of Expression 4 = 2
Result of Expression 5 = 0