struct foo and function foo !?

[Razvan]

Hi !

Today I saw some code like this:

struct foo {
foo(foo* s2){
cout << "foo::foo";
}
};

foo* foo(foo *s2)
{
cout << "foo::(foo* )";
return s2;
}

The name of the struct is 'foo' and the name of the
function is 'foo' also ! Why they are not conflicting ? The name of
types and the names of functions (and varialbles) are kept in separate
places ? Is this standard behaviour ?

Regards,
Razvan

[Razvan]

Tough question ?!!
Maybe somebody can pinpoint me to the right direction.

Razvan

mi*****@mailcit y.com (Razvan) wrote in message news:<15******* *************** *@posting.googl e.com>...

Hi !

Today I saw some code like this:

struct foo {
foo(foo* s2){
cout << "foo::foo";
}
};

foo* foo(foo *s2)
{
cout << "foo::(foo* )";
return s2;
}

The name of the struct is 'foo' and the name of the
function is 'foo' also ! Why they are not conflicting ? The name of
types and the names of functions (and varialbles) are kept in separate
places ? Is this standard behaviour ?

Regards,
Razvan

[Prateek R Karandikar]

> > Today I saw some code like this:

struct foo {
foo(foo* s2){
cout << "foo::foo";
}
};

foo* foo(foo *s2)
{
cout << "foo::(foo* )";
return s2;
}

The name of the struct is 'foo' and the name of the
function is 'foo' also ! Why they are not conflicting ? The name of
types and the names of functions (and varialbles) are kept in separate
places ? Is this standard behaviour ?

Yes, unfotunately this is Standard behaviour. A struct and a function
in the same scope can have the same name. It is one of the unwanted
leftovers of the C language. In C, foo wouldn't be a type, struct foo
would be a type, so there was no ambiguity. In C++ now foo itself is a
type, but the committee chose not to break C compatibility in this
case. However it is best to avoid this "feature". A good compiler
should give a warning.

-- --
Abstraction is selective ignorance.
-Andrew Koenig
-- --

[Denis Remezov]

Prateek R Karandikar wrote:

Today I saw some code like this:

struct foo {
foo(foo* s2){
cout << "foo::foo";
}
};

foo* foo(foo *s2)
{
cout << "foo::(foo* )";
return s2;
}

The name of the struct is 'foo' and the name of the
function is 'foo' also ! Why they are not conflicting ? The name of
types and the names of functions (and varialbles) are kept in separate
places ? Is this standard behaviour ?

Yes, unfotunately this is Standard behaviour. A struct and a function
in the same scope can have the same name. It is one of the unwanted
leftovers of the C language. In C, foo wouldn't be a type, struct foo
would be a type, so there was no ambiguity. In C++ now foo itself is a
type, but the committee chose not to break C compatibility in this
case. However it is best to avoid this "feature". A good compiler
should give a warning.

Just to add, a function declaration or definition will hide the name
of a class /in the same scope/ (now you would need to say "struct foo"
in order to get down to the name of the /struct/ foo).

An interesting part is the function declarator itself:
foo* foo(foo* s2)
Here, foo* is still considered a pointer to struct foo since
the declaration of function foo is not yet complete. If I were
not able to change the names, I would use "struct foo" here too;
otherwise, a forward declaration of function foo would cause a
compilation error in the definition.

Denis

[Razvan]

kp********@yaho o.com (Prateek R Karandikar) wrote in message news:<60******* *************** ****@posting.go ogle.com>...

Today I saw some code like this:

struct foo {
foo(foo* s2){
cout << "foo::foo";
}
};

foo* foo(foo *s2)
{
cout << "foo::(foo* )";
return s2;
}

The name of the struct is 'foo' and the name of the
function is 'foo' also ! Why they are not conflicting ? The name of
types and the names of functions (and varialbles) are kept in separate
places ? Is this standard behaviour ?

Yes, unfotunately this is Standard behaviour. A struct and a function
in the same scope can have the same name. It is one of the unwanted
leftovers of the C language. In C, foo wouldn't be a type, struct foo
would be a type, so there was no ambiguity. In C++ now foo itself is a
type, but the committee chose not to break C compatibility in this
case. However it is best to avoid this "feature". A good compiler
should give a warning.

Why are you saying that the function 'foo' is a type ? That
makes no sense to me. What king of variables can you define with this
type ?!!

Regards,
Razvan

[Richard Herring]

In message <15************ **************@ posting.google. com>, Razvan
<mi*****@mailci ty.com> writes

kp********@yah oo.com (Prateek R Karandikar) wrote in message
news:<60****** *************** *****@posting.g oogle.com>...

> > Today I saw some code like this:
> >
> > struct foo {
> > foo(foo* s2){
> > cout << "foo::foo";
> > }
> > };
> >
> > foo* foo(foo *s2)
> > {
> > cout << "foo::(foo* )";
> > return s2;
> > }
> >
> > The name of the struct is 'foo' and the name of the
> > function is 'foo' also ! Why they are not conflicting ? The name of
> > types and the names of functions (and varialbles) are kept in separate
> > places ? Is this standard behaviour ?

Yes, unfotunately this is Standard behaviour. A struct and a function
in the same scope can have the same name. It is one of the unwanted
leftovers of the C language. In C, foo wouldn't be a type, struct foo
would be a type, so there was no ambiguity. In C++ now foo itself is a
type, but the committee chose not to break C compatibility in this
case. However it is best to avoid this "feature". A good compiler
should give a warning.

Why are you saying that the function 'foo' is a type ? That
makes no sense to me. What king of variables can you define with this
type ?!!

Variables of type "pointer to {function taking one argument of type foo*
and returning a foo*}".

--
Richard Herring

[John Harrison]

"Razvan" <mi*****@mailci ty.com> wrote in message
news:15******** *************** ***@posting.goo gle.com...

kp********@yaho o.com (Prateek R Karandikar) wrote in message

news:<60******* *************** ****@posting.go ogle.com>...

> Today I saw some code like this:
>
> struct foo {
> foo(foo* s2){
> cout << "foo::foo";
> }
> };
>
> foo* foo(foo *s2)
> {
> cout << "foo::(foo* )";
> return s2;
> }
>
> The name of the struct is 'foo' and the name of the
> function is 'foo' also ! Why they are not conflicting ? The name of
> types and the names of functions (and varialbles) are kept in separate > places ? Is this standard behaviour ?

Yes, unfotunately this is Standard behaviour. A struct and a function
in the same scope can have the same name. It is one of the unwanted
leftovers of the C language. In C, foo wouldn't be a type, struct foo
would be a type, so there was no ambiguity. In C++ now foo itself is a
type, but the committee chose not to break C compatibility in this
case. However it is best to avoid this "feature". A good compiler
should give a warning.

Why are you saying that the function 'foo' is a type ? That
makes no sense to me. What king of variables can you define with this
type ?!!

function foo is not a type, struct foo is a type.

john

[Razvan]

Hi !


int someFunc (int a)
{
return a + 2;
}

In order to declare a pointer to such a func you can use:

typedef int (*ptr_to_func) (int);

This is how you define a type of pointer to some function. Then you
can write:
ptr_to_func pFunc = someFunc;

int rr = 10;
cout << pFunc(rr) << endl;
"someFunc" is not a type therefore you cannot use it like the type
ptr_to_func is used.


Regards,
Razvan