Conversion function problems

[Dave]

Hello all,

Can anybody help with the problem below? I'm trying to define a conversion
function that converts objects to function pointers and am getting a compile
error on the line indicated below. The compiler interprets this is a
function returning a function, which, of course is illegal... What is the
correct syntax to accomplish this?

Thanks,
Dave
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error here!
};

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

[Josephine Schafer]

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com...

Hello all,

Can anybody help with the problem below? I'm trying to define a conversion
function that converts objects to function pointers and am getting a compile
error on the line indicated below. The compiler interprets this is a
function returning a function, which, of course is illegal... What is the
correct syntax to accomplish this?

Thanks,
Dave
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error here!
};

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

Try this -
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}
typedef double (*fp)(int) ;
class foo_t
{
public:
operator fp(){return foo_func;}
};

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

HTH,
J.Schafer

[David White]

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com...

Hello all,

Can anybody help with the problem below? I'm trying to define a conversion function that converts objects to function pointers and am getting a compile error on the line indicated below. The compiler interprets this is a
function returning a function, which, of course is illegal... What is the
correct syntax to accomplish this?

Thanks,
Dave
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error here!

operator double (*())(int n) { return foo_func;}

DW

[David White]

"David White" <[e-mail]> wrote in message
news:cM******************@nasal.pacific.net.au...

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error

here!
operator double (*())(int n) { return foo_func;}

Sorry, my compiler is playing tricks on me. I'm sure that compiled without
error once, but it won't do it now. I don't know why. However, this works:

double foo_func(int n) {return n + 1.5;}

typedef double (*ff)(int n);

class foo_t
{
public:
operator ff() { return foo_func;}
};

DW

[John Carson]

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com

Hello all,

Can anybody help with the problem below? I'm trying to define a
conversion function that converts objects to function pointers and am
getting a compile error on the line indicated below. The compiler
interprets this is a function returning a function, which, of course
is illegal... What is the correct syntax to accomplish this?

Thanks,
Dave
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error
here! };

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

Do you really want to convert objects to function pointers or do you just
want an object that acts like a function? In the latter case, you can do it
with this:

class foo_t
{
public:
double operator()(int n)
{
return n + 1.5;
}
};
--
John Carson
1. To reply to email address, remove donald
2. Don't reply to email address (post here instead)

[Dave]

"Josephine Schafer" <no****************@hotmail.com> wrote in message
news:bq*************@ID-192448.news.uni-berlin.de...

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com...

Hello all,

Can anybody help with the problem below? I'm trying to define a conversion function that converts objects to function pointers and am getting a compile error on the line indicated below. The compiler interprets this is a
function returning a function, which, of course is illegal... What is the correct syntax to accomplish this?

Thanks,
Dave
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error here! };

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

Try this -
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}
typedef double (*fp)(int) ;
class foo_t
{
public:
operator fp(){return foo_func;}
};

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

HTH,
J.Schafer

Thx!!! Just out of curiosity, is it possible to do this without a typedef???
I've tried a bunch of different ideas, but none work. Is it syntactically
possible to do this without a typedef, or is a typedef required? For that
matter, is a typedef ever *required*???

[Dave]

"John Carson" <do***********@datafast.net.au> wrote in message
news:3f********@usenet.per.paradox.net.au...

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com

Hello all,

Can anybody help with the problem below? I'm trying to define a
conversion function that converts objects to function pointers and am
getting a compile error on the line indicated below. The compiler
interprets this is a function returning a function, which, of course
is illegal... What is the correct syntax to accomplish this?

Thanks,
Dave
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error
here! };

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}
Do you really want to convert objects to function pointers or do you just
want an object that acts like a function? In the latter case, you can do

it with this:

class foo_t
{
public:
double operator()(int n)
{
return n + 1.5;
}
};
--
John Carson
1. To reply to email address, remove donald
2. Don't reply to email address (post here instead)

I am indeed specifically trying to learn how to create a coversion function
to function pointer. My goal is to learn exactly this...

[Dave]

"David White" <[e-mail]> wrote in message
news:cM******************@nasal.pacific.net.au...

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com...

Hello all,

Can anybody help with the problem below? I'm trying to define a conversion

function that converts objects to function pointers and am getting a

compile

error on the line indicated below. The compiler interprets this is a
function returning a function, which, of course is illegal... What is the correct syntax to accomplish this?

Thanks,
Dave
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}

class foo_t
{
public:
operator double (*)(int)() {return foo_func;} // Compile error

here!
operator double (*())(int n) { return foo_func;}

DW

That was my next best guess too, but no go (unless it's a problem with my
compiler)!!

[John Carson]

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com

"Josephine Schafer" <no****************@hotmail.com> wrote in message
news:bq*************@ID-192448.news.uni-berlin.de...

Try this -
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}
typedef double (*fp)(int) ;
class foo_t
{
public:
operator fp(){return foo_func;}
};

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

HTH,
J.Schafer

Thx!!! Just out of curiosity, is it possible to do this without a
typedef??? I've tried a bunch of different ideas, but none work. Is
it syntactically possible to do this without a typedef, or is a
typedef required? For that matter, is a typedef ever *required*???

According to Lippman's C++ Primer (3rd ed), p. 777:
"A conversion function takes the general form
operator type();
where type is replaced by a built-in type, a class type, or a typedef name.
Conversion functions in which type represents either an array or a function
type are not allowed."

This is also discussed less plainly in the C++ standard, section 12.3.2.
Apparently using function pointers without a typedef creates ambiguities in
parsing the expression.
--
John Carson
1. To reply to email address, remove donald
2. Don't reply to email address (post here instead)

[Dave]

"John Carson" <do***********@datafast.net.au> wrote in message
news:3f******@usenet.per.paradox.net.au...

"Dave" <be***********@yahoo.com> wrote in message
news:vs************@news.supernews.com

"Josephine Schafer" <no****************@hotmail.com> wrote in message
news:bq*************@ID-192448.news.uni-berlin.de...

Try this -
#include <iostream>

using namespace std;

double foo_func(int n) {return n + 1.5;}
typedef double (*fp)(int) ;
class foo_t
{
public:
operator fp(){return foo_func;}
};

int main()
{
foo_t f;

cout << f(12) << endl; // Expecting "13.5"...

return 0;
}

HTH,
J.Schafer
Thx!!! Just out of curiosity, is it possible to do this without a
typedef??? I've tried a bunch of different ideas, but none work. Is
it syntactically possible to do this without a typedef, or is a
typedef required? For that matter, is a typedef ever *required*???

According to Lippman's C++ Primer (3rd ed), p. 777:
"A conversion function takes the general form
operator type();
where type is replaced by a built-in type, a class type, or a typedef

name. Conversion functions in which type represents either an array or a function type are not allowed."

This is also discussed less plainly in the C++ standard, section 12.3.2.
Apparently using function pointers without a typedef creates ambiguities in parsing the expression.
--
John Carson
1. To reply to email address, remove donald
2. Don't reply to email address (post here instead)

Ahh, OK, cool! Can anybody cite any other cases where a typedef is
*required* to accomplish something???

[David White]

"John Carson" <do***********@datafast.net.au> wrote in message
news:3f******@usenet.per.paradox.net.au...

According to Lippman's C++ Primer (3rd ed), p. 777:
"A conversion function takes the general form
operator type();
where type is replaced by a built-in type, a class type, or a typedef name. Conversion functions in which type represents either an array or a function type are not allowed."
But you can't return an array or function from any other kind of function
either, not just a conversion operator, with or without a typedef.
This is also discussed less plainly in the C++ standard, section 12.3.2.
Apparently using function pointers without a typedef creates ambiguities in parsing the expression.

Even if the standard doesn't allow it, I'm not convinced that the Lippman
extract has anything to do with requiring a typedef to return a function
pointer. Does he give the general form of a function as this?
type name(/*parameters*/)

which excludes the tiny fraction of functions that don't conform, such as:
double (*f())(int);

(It is just a primer, after all).

DW

[John Carson]

"David White" <[e-mail]> wrote in message
news:vY******************@nasal.pacific.net.au

"John Carson" <do***********@datafast.net.au> wrote in message
news:3f******@usenet.per.paradox.net.au...

According to Lippman's C++ Primer (3rd ed), p. 777:
"A conversion function takes the general form
operator type();
where type is replaced by a built-in type, a class type, or a
typedef name. Conversion functions in which type represents either
an array or a function type are not allowed."

But you can't return an array or function from any other kind of
function either, not just a conversion operator, with or without a
typedef.

The 1998 standard say this in section 8.3.5, p4:

"Functions shall not have a return type of type array or function, although
they may have a return type of type pointer or reference to such things."

The following is an example that works (without even a typedef):

#include <iostream>
using namespace std;

double f0(double n)
{
return n;
}
double f1(double n)
{
return n+1;
}
double f2(double n)
{
return n+2;
}

// this is a function taking an integer argument
// and returning a pointer to a function that
// takes a double as argument and returns a double

double (*function(int x))(double)
{
if(x==1)
return f1;
else if(x==2)
return f2;
else
return f0;
}

int main()
{
cout << function(1)(9.3)<< endl; // expect 10.3
cout << function(2)(9.3)<< endl; // expect 11.3
return 0;
}
--
John Carson
1. To reply to email address, remove donald
2. Don't reply to email address (post here instead)

[David White]

"John Carson" <do***********@datafast.net.au> wrote in message
news:3f******@usenet.per.paradox.net.au...

"David White" <[e-mail]> wrote in message
news:vY******************@nasal.pacific.net.au

But you can't return an array or function from any other kind of
function either, not just a conversion operator, with or without a
typedef.
The 1998 standard say this in section 8.3.5, p4:

"Functions shall not have a return type of type array or function, although
they may have a return type of type pointer or reference to such things."

The following is an example that works (without even a typedef):

#include <iostream>
using namespace std;

double f0(double n)
{
return n;
}
double f1(double n)
{
return n+1;
}
double f2(double n)
{
return n+2;
}

// this is a function taking an integer argument
// and returning a pointer to a function that
// takes a double as argument and returns a double

double (*function(int x))(double)

And in my previous post, this was a function returning a pointer to a function taking an int
parameter and returning a double:
double (*f())(int);
{
if(x==1)
return f1;
else if(x==2)
return f2;
else
return f0;
}

int main()
{
cout << function(1)(9.3)<< endl; // expect 10.3
cout << function(2)(9.3)<< endl; // expect 11.3
return 0;
}

I'm not sure what your point is. The statement you seem to have replied to remains the case,
i.e., that you can't return a function or an array from anything.

DW

[John Carson]

"David White" <[e-mail]> wrote in message
news:85******************@nasal.pacific.net.au

I'm not sure what your point is. The statement you seem to have
replied to remains the case, i.e., that you can't return a function
or an array from anything.

Well...I wasn't sure what your point was. I thought (though I wasn't sure)
that you were disputing that there was a special need for typedefs where
conversion operators are concerned. I was taking it as given that we were
interested in the return of pointers to functions rather than the return of
functions.

I now think that you are simply disputing my interpretation of the Lippman
quote:

"A conversion function takes the general form
operator type();
where type is replaced by a built-in type, a class type, or a typedef name.
Conversion functions in which type represents either an array or a function
type are not allowed."

You will note that Lippman makes no reference at all to pointers, yet a
conversion operator can certainly return, say, a pointer to a class type.
Accordingly, I interpreted all his statements about types as including
pointers to those types. Thus I interpret him as saying that a conversion
operator cannot return an explicit function pointer but can return a typedef
name for a function pointer.

I admit that this interpretation is arguable, but it does seem to conform to
what I observe of compiler behaviour.

--
John Carson
1. To reply to email address, remove donald
2. Don't reply to email address (post here instead)

[David White]

"John Carson" <do***********@datafast.net.au> wrote in message
news:3f********@usenet.per.paradox.net.au...

"David White" <[e-mail]> wrote in message
news:85******************@nasal.pacific.net.au

I'm not sure what your point is. The statement you seem to have
replied to remains the case, i.e., that you can't return a function
or an array from anything.

Well...I wasn't sure what your point was. I thought (though I wasn't sure)
that you were disputing that there was a special need for typedefs where
conversion operators are concerned. I was taking it as given that we were
interested in the return of pointers to functions rather than the return

of functions.

I now think that you are simply disputing my interpretation of the Lippman
quote:
That's right.
"A conversion function takes the general form
operator type();
where type is replaced by a built-in type, a class type, or a typedef name. Conversion functions in which type represents either an array or a function type are not allowed."

You will note that Lippman makes no reference at all to pointers, yet a
conversion operator can certainly return, say, a pointer to a class type.
Accordingly, I interpreted all his statements about types as including
pointers to those types. Thus I interpret him as saying that a conversion
operator cannot return an explicit function pointer but can return a typedef name for a function pointer.

Yes, I'm not as sure about my interpretation now. Even a primer should get
it right, but I was unfairly implying that it might be a little sloppy.

DW