--%>

Scope resolution operator

The scope resolution operator (: : ) in C++ is used to define the declared member functions (in the header file with cpp extension) of the in the cpp file one can define the normal functions or the number functions of the class. To differentiate from the normal functions with the member functions of the class, one needs to the use the scope resolution operator (: : ) in between the class name and the member function name, ship : : foo () where the ship is class and the foo () is member function in the ship. The other applications of the resolution operator is to resolve the scope of the variables if the identical variable name is used for local, global, and the data member of the class. If the resolution operator is placed between the class name and the data member belonging to the class than data name belonging to the particular class is affected. If the resolution operator is placed in front of the variable name than the global variable is affected. If no resolution operator is placed then the global the local variable is affected. You can inform the compiler to utilize the global identifier rather than local identifier through prefixing the identifier with : : the scope resolution operator.

: : identifier

Class name : : identifier

Name space : : identifier // the identifier can be a variable or a function.

If we have nested local scopes, the scope resolution operator does not provide access to identifier in the next outer most scope. It gives access to only the universal identifiers. This instance has two variables namely amount. The first one is global and consists of the value 123. The second is restricted to the main function. The scope resolution operator states the compiler to utilize the global amount in spite of the local one.

# include < iostream. h >

Using name space std;

Int amount = 123; // a global variable

Int main ()

{

Int amount = 456; // a local variable

Cout << : : amount << end l; // print the global variable

   Cout << : : amount << end l; // print the local variable

                 }

   Related Questions in Programming Languages

  • Q : Define Container Abstractions Container

    Container Abstractions: Abstractions for containers (such as lists, stacks, sets, or queues) may represent just the state of a container—e.g., full or empty—and abstract away from the actual container content. The list operations also need

  • Q : Define Bounds Bounds : It is the limits

    Bounds: It is the limits of an array or collection. In Java, the lower limit is for all time zero (0). In case of an array, the upper bound is one less than the length of the array, and is fixed. Indexing exterior the bounds of an array or collection

  • Q : Use the Processing program for the

    1. Here is a short program. It prints out the value of a variable "x". Ernie and Bert disagree about what will be printed: Ernie says, the value gets changed in "changeX" so it will print "7", and Bert says, no, when the function exits the changes get reversed and the value goes back to "5". Expl

  • Q : Determine a web page element which

    How can I determine a web page element which contains exact text?

  • Q : Index value of the initial element in

    Write the index value of the initial element in an array?

  • Q : What is Server Server : Something which

    Server: Something which gives a service. The Web server delivers resources to its clients, for example. Whenever the server is an object, this is the recipient of messages from its object clients.

  • Q : State the term snooping State the term

    State the term snooping?

  • Q : What is Abstract method Abstract method

    Abstract method: This is a method with the abstract reserved word in its header. The abstract method has no method body. Methods stated in an interface are for all time abstract. The body of an abstract method should be stated in a su

  • Q : Explain the meaning of semantic

    Explain the meaning of semantic connotations.

  • Q : What is an Overriding for chaining

    Overriding for chaining: It is a form of method overriding in which the sub-class version of a method verifies to see whether it can react to the message on its own and just calls the super-class version of the method.