metaprogramming solution to recursive function typedef ?

[Roshan Naik]

typedef int foo ( foo ); // foo is a pointer-to-function type that takes
another foo as argument and returns an int

I need to achieve the above effect somehow. This is not accepted by any
compiler I have tried, even though I cant spot anything in the standard that
restricts it.

Is there a way to achieve this typedefintion using metaprogramming ? I
noticed that boost::variant does some metaprogramming tricks to allow

variants to be contained in variants. But it is unclear to me how that is
acheived, also that problem _may_ not be exactly the same as this.

-Roshan Naik

[Kai-Uwe Bux]

Roshan Naik wrote:

typedef int foo ( foo ); // foo is a pointer-to-function type that takes
another foo as argument and returns an int

I need to achieve the above effect somehow.

What is the real underlying problem that you are trying to solve?

[snip]
Best

Kai-Uwe Bux

[Alf P. Steinbach]

* Roshan Naik:

typedef int foo ( foo ); // foo is a pointer-to-function type that takes
another foo as argument and returns an int

I need to achieve the above effect somehow.

struct Foo
{
virtual int operator()( Foo const* ) const = 0;
};

Then if you need to pass such functors by value, you can wrap them in a
functor with a smart-pointer to the actual functor.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Greg]

Roshan Naik wrote:

typedef int foo ( foo ); // foo is a pointer-to-function type that takes
another foo as argument and returns an int

I need to achieve the above effect somehow. This is not accepted by any
compiler I have tried, even though I cant spot anything in the standard that
restricts it.

Is there a way to achieve this typedefintion using metaprogramming ? I
noticed that boost::variant does some metaprogramming tricks to allow

variants to be contained in variants. But it is unclear to me how that is
acheived, also that problem _may_ not be exactly the same as this.

Perhaps you want something along these lines:

template <class T>
struct CallFunctionPtr
{
typedef int (*functionPtr)( T);

typedef CallFunctionPtr <fPtr> next;
};

int main()
{
CallFunctionPtr <int(*)()>::nex t::functionPtr fPtr;

// fPtr is of type int (*)(int (*)())

CallFunctionPtr <int(*)()>::nex t::next:::funct ionPtr f2Ptr;

// f2Ptr is of type int (*)(int (*)(int (*)()))
}

Each "next" inner type corresponds to a function call to a function
whose pointer is being passed as a parameter. The number of "next"'s
that are chained together equals how many functions will be called
before the nested function pointers are exhausted.

Greg

[Pete Becker]

Roshan Naik wrote:

typedef int foo ( foo ); // foo is a pointer-to-function type that takes
another foo as argument and returns an int

The comment is incorrect, for two reasons. First, foo is not defined,
because this is not a valid declaration. But you knew that. <g>

Second, if the argument type were changed from foo to, say, int, then
foo would not be a pointer to function type. It would be a function type.

--

Pete Becker
Dinkumware, Ltd. (http://www.dinkumware.com)

[Roshan Naik]

"Alf P. Steinbach" <al***@start.no > wrote in message
news:43******** ********@news.i ndividual.net.. .

struct Foo
{
virtual int operator()( Foo const* ) const = 0;
};

Then if you need to pass such functors by value, you can wrap them in a
functor with a smart-pointer to the actual functor.

Thanks. But I already considered that and i need to have a real function
type. So i can use more
terse syntax like this...

int myFunc1 ( foo arg) {
//. ..
}

instead of having to write classes deriving from Foo and then implementing
( ) as a member function.

-Roshan

[Dan Cernat]

Roshan Naik wrote:

typedef int foo ( foo ); // foo is a pointer-to-function type that takes
another foo as argument and returns an int

<snip>

so foo is
a pointer to a function that has as a sole argument
a pointer to a function that has as a sole argument
a pointer to a function that has as a sole argument
.....

/dan

[Roshan Naik]

"Pete Becker" <pe********@acm .org> wrote in message
news:Rc******** ************@rc n.net...

Roshan Naik wrote:

typedef int foo ( foo ); // foo is a pointer-to-function type that takes another foo as argument and returns an int

The comment is incorrect, for two reasons. First, foo is not defined,
because this is not a valid declaration. But you knew that. <g>

Please elaborate. I assume that the above declaration (if it would be
accpeted by any compiler)
would be equivalent to.....
typedef int (*foo) (foo);

Note that I can use A* within the declaration of class A. Thus foo here
doesnt have to be defined as its a pointer type (my way of thinking).
Second, if the argument type were changed from foo to, say, int, then
foo would not be a pointer to function type. It would be a function type.

Is there such a thing as "function type" for variables in C++ ? It is my
understanding that you can only
have a pointers/references to functions. There is no way to define a
value-type variable that holds a function.
You can only declare a pointer-type variable that stores the address of a
function.

A function itself has a "function type" but from the standpoint of declaring
a variable/parameter
we have to use pointer to function types.

-Roshan

[Pete Becker]

Roshan Naik wrote:

A function itself has a "function type" but from the standpoint of declaring
a variable/parameter
we have to use pointer to function types.

In C that is correct. In C++ you can also create a reference to function
type, although that's of minor utility. Nevertheless, in both C and C++,
typedef int foo(int); defines a function type, not a pointer to function
type. To define a pointer to function type you need a *, which says
'pointer'.

--

Pete Becker
Dinkumware, Ltd. (http://www.dinkumware.com)

[Roshan Naik]

> In C that is correct. In C++ you can also create a reference to function

type, although that's of minor utility. Nevertheless, in both C and C++,
typedef int foo(int); defines a function type, not a pointer to function
type. To define a pointer to function type you need a *, which says
'pointer'.

And of what use is a function type ?

-Roshan