Re: Covariant virtual function result types
Am 28.11.2011 23:31, schrieb Lorenzo:
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'm not screaming, but I'm still not sure what *precisely* you want,
lets follow what you write:
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");
Fine so far.
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");
}
You cannot do this, correct, but what is wrong with
struct lbase {
template<typename T>
void f(T const& x) {}
};
void test() {
lbase l;
l.f(123);
l.f("abc");
}
?
Note that you have not presented anything interesting yet that
demonstrates why you need lbase to be a local class.
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;
}
Except for much more complications in your code above, why would
#include<iostream>
struct lbase {
template<typename T>
void f(T const& x) { std::cout<< x<< std::endl; }
};
void test() {
struct ltype : lbase {} l;
l.f(123);
l.f("abc");
}
not solve your problem as well? (The class derivation is not necessary
here, I just use this to demonstrate the analogy to your code above)
Does this have to do with function objects in local scope that should
have an operator() overload which is a function template?
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...).
You don't really explain the reason for your type-erase-type-unerasure
cycle (except that you want to demonstrate how to fake compile-time
polymorphic local classes), but if you really want to follow this route,
you should better use boost::any for the erased type instead of
dangerous hacks with va_list's. boost::any provides access to an
std::type_info object of the wrapped type, but using this here would
still require a switch over possible types. This switch must naturally
be finite, so cannot cover all types in general. Nonetheless I mention
this here, because it could be that your actual types are within a
limited set of types that you all know.
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.
By the nature of dynamic polymorphism this is not possible. Why not
using the function template directly?
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...
Well, yes, this cannot work.
I think we need to get more information for what you want to realize, as
explained above.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]