IGNOU BCA 3rd sem Solved Assignment - Explain the usage of the following C++ operators with the help of an example program (a) sizeof operator (b) Logical Operators (c) Scope resolution operator

Explain the usage of the following C++ operators with the help of an example program

(a)          sizeof operator

(b)         Logical Operators

(c)          Scope resolution operator

Ans

usage of the c++ sizeof operator

The sizeof is a keyword, but it is a compile-time operator that determines the size, in bytes, of a variable or data type.

The sizeof operator can be used to get the size of classes, structures, unions and any other user defined data type.

The syntax of using sizeof is as follows:

sizeof (data type)

Where data type is the desired data type including classes, structures, unions and any other user defined data type.

Try following example to understand all the sizeof operator available in C++. Copy and paste following C++ program in test.cpp file and compile and run this program.

#include <iostream>

using namespace std;

int main()

{

   cout << "Size of char : " << sizeof(char) << endl;

   cout << "Size of int : " << sizeof(int) << endl;

   cout << "Size of short int : " << sizeof(short 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 wchar_t : " << sizeof(wchar_t) << endl;

   return 0;

}

When the above code is compiled and executed, it produces following result which can vary from machine to machine:

Size of char : 1

Size of int : 4

Size of short int : 2

Size of long int : 4

Size of float : 4

Size of double : 8

Size of wchar_t : 4

usage of the c++ Logical Operators

The Operator ! is the C++ operator to perform the Boolean operation NOT, it has only one operand, located at its right, and the only thing that it does is to inverse the value of it, producing false if its operand is true and true if its operand is false. Basically, it returns the opposite Boolean value of evaluating its operand. For example

!(5 == 5)    // evaluates to false because the expression at its right (5 == 5) is true.

!(6 <= 4)    // evaluates to true because (6 <= 4) would be false.

!true        // evaluates to false

!false       // evaluates to true.

The logical operators && and || are used when evaluating two expressions to obtain a single relational result. The operator && corresponds with Boolean logical operation AND. This operation results true if both its two operands are true, and false otherwise.

The operator || corresponds with Boolean logical operation OR. This operation results true if either one of its two operands is true, thus being false only when both operands are false themselves

For example:

( (5 == 5) && (3 > 6) )  // evaluates to false ( true && false ).

( (5 == 5) || (3 > 6) )  // evaluates to true ( true || false ).

When using the logical operators, C++ only evaluates what is necessary from left to right to come up with the combined relational result, ignoring the rest. Therefore, in this last example ((5==5)||(3>6)), C++ would evaluate first whether 5==5 is true, and if so, it would never check whether 3>6 is true or not. This is known as short-circuit evaluation, and works like this for these operators:

operator	short-circuit
&&	if the left-hand side expression is false, the combined result is false (right-hand side expression not evaluated).
||	if the left-hand side expression is true, the combined result is true (right-hand side expression not evaluated).

This is mostly important when the right-hand expression has side effects, such as altering values:

if ((i<10)&&(++i<n)) { /*...*/ }

This combined conditional expression increases i by one, but only if the condition on the left of && is true, since otherwise the right-hand expression (++i<n) is never evaluated.

usage of the c++ Scope resolution operator

The :: (scope resolution) operator is used to qualify hidden names so that you can still use them. You can use the unary scope operator if a namespace scope or global scope name is hidden by an explicit declaration of the same name in a block or class. For example:

int count = 0;

int main(void) {

  int count = 0;

  ::count = 1;  // set global count to 1

  count = 2;    // set local count to 2

  return 0;

}

The declaration of count declared in the main() function hides the integer named count declared in global namespace scope. The statement ::count = 1 accesses the variable named count declared in global namespace scope.

You can also use the class scope operator to qualify class names or class member names. If a class member name is hidden, you can use it by qualifying it with its class name and the class scope operator.

In the following example, the declaration of the variable X hides the class type X, but you can still use the static class member count by qualifying it with the class type X and the scope resolution operator.

#include <iostream>

using namespace std;

class X

{

public:

      static int count;

};

int X::count = 10;                // define static data member

int main ()

{

      int X = 0;                  // hides class type X

      cout << X::count << endl;   // use static member of class X