C++Talk.NET

liftmaster · Guest

is there a way of specifying a specific overload of some function when
writing function pointer specifier?

I am trying to find information about the return value of of a dereference
operation by interrogating the type of the operator* function pointer. I
can distinguish between member and nonmember operator* and I can specify a
member operator* and test it like this:

template<class It, bool _IsMember_>
struct dereference_properties
{
static yes_t char_test (It::char(*)());
static yes_t char_test (It::char(*)()const);
static yes_t char_test (It::char(*)()volatile);
static yes_t char_test (It::char(*)()const volatile);
// NB no static operator*

static no_t char_test (...);

enum {is_char = sizeof(char_test(&It::operator*))
==sizeof(yes_t) };

};

im sorry for typeos,I don't have a compiler here to check that the code I
am writing is totally correct. obviously the above test is not exaclt the
test I am making.

but fornonmember operator* we cannot do this:

template<class It>
struct dereference_properties<It, false>
{
static yes_t char_test (char(*)(It));
static yes_t char_test (char(*)(It&)const);
static yes_t char_test (char(*)(const It&);

static no_t char_test (...);

enum {is_char = sizeof(char_test(&operator*))
==sizeof(yes_t) };

};

because the compiler has no idea which operator* we want and makes no
attemptto look for operator*s in the namespaceof It.

Is there a way 'round this.

Obviously there is a further limitation that we wish to be able to specify
the overload, but it would be even nicer if, as in the speculative (but
wrong) code above we could specify a few possible overloads and so long as
one and only one of them is fulfilled the compiler would pick the correct
one (as it does for the mnember function operator*).

I hope this is clear. I don't think there is a solution but I don't want
to give up without asking around.

p.s. yes I MUST have the member function pointer, just dereferencing
simply won't do (I think).

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Maxim Yegorushkin · Guest

On Fri, 08 Jul 2005 19:00:15 +0400, liftmaster <maninalift (AT) another (DOT) com>
wrote:

liftmaster · Guest

Finding whether an object defines an operator*, or indeed finding whether
that operator is defined as a member or non-member is not the problem.

The problem is, if the function is a non-member I am unable to specify the
function pointer pointing to that operator*, since I am specifying a
function which is overloaded. If I just write "operator*" the compiler
will not know that I mean

unknow_rtn_t operator*(this_object)

indeed the compiler won't even look for an (as yet) undeclared or
non-local operator*.

As I say I don't think there is a solutin to this problem but if anyone
sees one please let me know.

cheirz

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Maxim Yegorushkin · Guest

On Mon, 11 Jul 2005 19:16:03 +0400, liftmaster <maninalift (AT) another (DOT) com>
wrote: