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]

yv*********@gmail.com wrote:

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]

On 11 May 2005 14:20:11 -0700, yv*********@gmail.com
<yv*********@gmail.com> wrote:

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
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;
}

[ben]

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

"ulrich" <ua********@aon.at> wrote in message
news:opsqnh31uon2mgp5@innsbruck-neu...

On 11 May 2005 14:20:11 -0700, yv*********@gmail.com
<yv*********@gmail.com> wrote:

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

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;
}

[yvinogradov]

Thanks everyone - it was enlightening :)

[Rolf Magnus]

ben wrote:

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.