c++ and 'single colon'

[yvinogradov]

I have a qustion about the attached piece of code. It compiles on gcc
version 3.4.1 (Cygwin special). The line in question has a single colon
instead of double. With double colon everything works as expected and
the base class implementation of foo() is called. With the single colon
the derived class implementation of foo() keeps calling itself
recursively. What does this single colon mean in this case?

Thanks.


-------------------------------------------------------------
#include <iostream>

class A {
public:
virtual void foo() {
std::cout << "A::foo()" << std::endl;
}
};

class B : public A {
public:
void foo() {
std::cout << "B::foo()" << std::endl;
A:foo(); // <----------------------------- Line in question
}
};

int main() {
B b;
b.foo();
return 0;
}

 

[Rolf Magnus]

I have a qustion about the attached piece of code. It compiles on gcc
version 3.4.1 (Cygwin special). The line in question has a single colon
instead of double. With double colon everything works as expected and
the base class implementation of foo() is called. With the single colon
the derived class implementation of foo() keeps calling itself
recursively. What does this single colon mean in this case?

The single colon means that the name before it is the name of a label that
you can jump to with goto.

 

[Jonathan Mcdougall]

I have a qustion about the attached piece of code.

It compiles on gcc version 3.4.1 (Cygwin special).
The line in question has a single colon instead of
double. With double colon everything works as
expected and the base class implementation of
foo() is called. With the single colon the derived
class implementation of foo() keeps calling itself
recursively. What does this single colon mean in
this case?
Nothing.

#include <iostream>

class A {
public:
virtual void foo() {
std::cout << "A::foo()" << std::endl;
}

};

class B : public A {
public:
void foo() {
std::cout << "B::foo()" << std::endl;
A:foo(); // <-------- Line in question

Replace 'A' by 'my_label' and put 'foo();' on another
line. Blink, laugh and hit your forehead on the desk.

}
};

Jonathan

 

[ulrich]

I have a qustion about the attached piece of code. It compiles on gcc
version 3.4.1 (Cygwin special). The line in question has a single colon
instead of double. With double colon everything works as expected and
the base class implementation of foo() is called. With the single colon
the derived class implementation of foo() keeps calling itself
recursively. What does this single colon mean in this case?

doesn't the single colon make the A there to a possible jump target for a
goto-statement?
ulrich

 

[ben]

Isn't it redundant because there's no goto in the program

 

[yvinogradov]

Thanks everyone - it was enlightening

 

[Rolf Magnus]

Isn't it redundant because there's no goto in the program

Yes, it is. And if you switch warnings on, g++ will detect it and warn about
it.