Thread: use of ::

Err... The first one when the method is part of a class, and the second when it is not part of a class. For more on classes, you can go to the tutorials on this site, or search this forum (I know Stack Overflow made a nice post on classes recently -- I'll see if I can find it).

*edit*
The Brain has a nice post on them here: http://cboard.cprogramming.com/showthread.php?t=59027

Elad makes some good points on them here:
http://cboard.cprogramming.com/showthread.php?t=58661

Hmm... I can't find Stack Overflow's so I may be lying about that one (although I could've sworn there was one recently). :shrugs:
Those others should help, though.

Appears to be a typo in the tutorial.
It should be 'void btree::destroy_tree(node* leaf)'.

The only time you would not is when you define the function inside the declaration of the class. E.g.

Code:

class foo
{
   void bar1( )
   {
      // Stuff here...
   }

   void bar2( );
};

void foo::bar2( )
{
   // Stuff...
}

Static methods belong to the class and not to any instance of the class. That is to say, when you call them, there is no 'this' pointer sent to them. Consequently, they cannot modify non-static data of the class. They can be called without an object, though, as in 'SomeClass::SomeFunc( )'. Normal, non-static functions cannot be called this way.

*edit*
You can also use the scope resolution operator (::) when calling a base-class method in a derived class, which somewhat breaks the rule above, but is somewhat of a special case.

Hello,

Member functions maybe defined outside the structure, by using the name of the structure, followed by a scope resolution operator, followed by the name of the member function. The scope resolution operator in C++ is, ::

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

Code:

int i = 10;

int f(int i) {
	return i ? i : :: i;	// return global i if local i is zero
}

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. Whenever a name is followed by a :: operator, the name is interpreted as a class name.

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.

Code:

#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

	return 0;
}

The Binary and Unary scope resolution operator's associativities are read left-to-right. Keep in mind the scope resolution and global scope operators are different. For example:

Code:

Operator	Description		Usage and Notes
::		scope resolution	class_name :: member
::		global			:: name

All in all, you can use the scope resolution operator to reference global variables, to reference hidden members in base classes, to explicitly reference a member that is inherited, or to otherwise name a member hidden by the current context. When you are in the context of a nested class, you must use the scope resolution operator to access members of the enclosing class.


- Stack Overflow

Okay... Now there is a nice post on the topic by Stack Overflow.

Originally Posted by Zach L.

Okay... Now there is a nice post on the topic by Stack Overflow.

Heh. I never recalled making a post about this before, so I thought I'd try!

Originally Posted by Zach L.

Hmm... I can't find Stack Overflow's so I may be lying about that one (although I could've sworn there was one recently).

Ah, don't worry about it. It was right under your nose.

Originally Posted by Cowboy

i ran out of ram reading that post...let me try it again lol

Ah. A 256MB stick can do wonders, sometimes.


- Stack Overflow

Alright,

My examples may have been convincing, though the truth underlying the scope resolution operator is this:

• Reference global variables
• Reference hidden members in base classes
• Explicitly reference a member that is inherited [or to otherwise name a member hidden by the current context]
• Access members of the enclosing class when in the context of a nested class

It is quite simple. My examples showed the use of these somewhat and are not the only ways the scope resolution operator can be used. If you keep the 4 key points of the operator, everything else should become clear.


- Stack Overflow

Originally Posted by Cowboy

man you read like my text book lol...

Its pieceing together now, thank you...have you ever considered writing a c++ book (even though there are billions out there)? lol

Glad to be of assistance. I apologize if I came across with too much detail and very little example. Though I have not considered writing a C or C++ book. I may sometime in the future, but I'm still in the learning process. I teach what I know to my best ability.


- Stack Overflow