Re: address of virtual member function passed as template argument
On 16 Mrz., 22:46, "Alex Blekhman" <x...@oohay.moc> wrote:
<pascal.zschu...@gmail.com> wrote:
Hello
My problem is that the following code using some very
specific stuff
fails to compile on MSVC8:
<code>
// main.cpp
//
// the error is:
// main.cpp(8) : fatal error C1001: internal compiler
error.// (File
"msc1.cpp", Line 1392)
#include <iostream>
// just a simple classtemplatewhich "holds" an address
of a member
//function
// i found out that this class doesn't even need to
contain anything
// else than this to produce the error
template<class Class, void(Class::*MemberFunction)()>
class mfaddr_hold
{
};
class Foo
{
public:
void f1() {}
virtualvoid f2() {}
};
class Boom
{
public:
void f1() {}
virtualvoid f2() {}
mfaddr_hold<Foo, &Foo::f1> h1; // other class,
normalfunction
-> works
mfaddr_hold<Foo, &Foo::f2> h2; // other class,
virtual
function-> works
mfaddr_hold<Boom, &Boom::f1> h3; // same class,
normal
function-> works
mfaddr_hold<Boom, &Boom::f2> h4; // same class,
virtual
function-> internal compiler error
};
int main(int argc, char* argv[])
{
return 0;
}
</code>
The Code works with gcc4.
The problem in MSVC8 is that i can't pass the address of a
virtual
member
functionof a class (here Boom) to a member variable in
the same class
astemplateparameter ;)
Do you guys know any solutions to solve this? any
workarounds?
Possible workaround depends on what `mfaddr_hold' actually
does. Using your code I came up with workaround using
`std::mem_fun_t':
#include <functional>
...
class Boom
{
public:
Boom() :
h1(&Foo::f1),
h2(&Foo::f2),
h3(&Boom::f1),
h4(&Boom::f2)
{}
void f1() {}
virtualvoid f2() {}
std::mem_fun_t<void, Foo> h1;
std::mem_fun_t<void, Foo> h2;
std::mem_fun_t<void, Boom> h3;
std::mem_fun_t<void, Boom> h4;
};
int main()
{
Boom b;
Foo f;
b.h1(&f);
b.h2(&f);
b.h3(&b);
b.h4(&b);
return 0;
}
Everything compiles and works perfectly.
Alex
The problem is that this doesn't fit my needs. But thank you for your
response.
I want to use Boost.Property and therefor it need to pass those
addresses to boost::property::object_property<...>
consider the following example:
<code>
class foo
{
private:
int value;
public:
int getValue() const { return value; }
void setValue(const int& v) { value = v; }
boost::scalar_property< boost::object_property
<
char, foo,
&foo::getValue,
&foo::setValue
};
</code>
If you make getValue() oder setValue() virtual, it crashes.
Well, i could pass pointers to getValue and setValue to the property
using it's custuctor at RunTime.
But i had to write my own property-lib for that and (more importantly)
it wouldn't fit into my OOP-system that well. (would be better if
every devired class _had_ to use getValue and setValue for their
properties)