Re: Covariant virtual function result types

On Nov 25, 2:25 am, "Yordan Naydenov" <dax_u...@abv.bg> wrote:


Hello all,

I feel I should explain you the background of my question... but it's
such a bogus attempt that I don't even know where to start... don't
scream at me saying that I'm crazy :)

I was trying to see if there any trick to define a function within a
local type that has polymorphic behavior in its parameter type.
Normally, this is done using template:

// some non-local scope:
template<typename T>
void f(T x) {}

f(123);
f("abc");

f can be called with int, string, etc :) However, templates cannot be
part of a local type, not even in C++011 :( In other words, the
following doesn't compile:

void f() {
    struct ltype {
        template<typename T> // Error: Can't do this :(
        void f(T x) {}
    } l;
    l.f(123);
    l.f("abc");
}

So I was thinking of putting the template into a base of ltype (lbase)
and then using variadic arguments but then I again need the actual
type when I extract the variadic argument:

#include <iostream>
#include <cstdarg>

template<typename T>
void f(T const& x) { std::cout << x << std::endl; }

struct lbase {
    virtual void body(int argc, ...) = 0;

    template<typename T>
    void f(T const& x) { body(1, x); }
};

int main ( ) {
    f(123);
    f("abc");

    struct ltype : lbase {
        void body(int argc, ...)
        {
            va_list argv;
            va_start(argv, argc);
            auto x = va_arg(argv, int); // I need the type :(
            {
                std::cout << "body " << x << std::endl;
            }
            va_end(argv);
        }
    } l;
    l.f(123);
    l.f("abc");

    return 0;
}

Now I can call l.f(123) and l.f("abc") and both these calls will end
up calling the body() (variadic arguments might not even be really
needed for that). But in the body I need to know x's type (int,
string, etc) in order to extract it so I was looking into ways around
that (there might be none because the compiler really needs x's type
information statically in order to compile the body function...).

I was trying to have lbase::f encapsulate the type information T into
a base class argbase that will then expose it via a covariant virtual
function. argbase will be passed as another parameter to the body and
then I could use decltype(argbase.covariant_virtual_func()) inside
body to deduce the type T of the argument x. My attempt failed
miserably...

All in all, I think what I was trying to do is wrong (how could the
compiler compile body if x's type is not explicitly known??) but I
wanted to ask.

Thanks a lot.
--Lorenzo

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