C++Talk.NET

Maximilian Hrabowski · Guest

Hallo allerseits,

bitte werft einen Blick auf folgendes Programm-Fragment.

Das ganze demonstriert die Nutzung eines Funktionsobjektes
"mem_fun_ref_wrapper_t" über die template funtion mem_fun_ref_wrap.

mem_fun_ref_wrapper_t ist ein Functionsobjekt das es ermöglicht
Rückgabewerte von Methoden eines Objektes als Parameter an ein anderes
Funktionsobject zu übergeben, das normalerweise den Objekttyp als
Parameter erhalten würde, z.B:

class Foo
{
Foo();
public:
int number() const;
};

std::vector<Foo> myFoos;

std::find_if( myFoos.begin(), myFoos.end(), std::mem_fun_ref_wrap(
bind1st( std::equal_to<int>(), 2 ), &Foo::number ) )

liefert iterator auf erstes Foo das für number() 2 zurückgibt.

Das Programm compiliert fehlerfrei mit gcc 3.3.3 und tut das Erwartete.

Mit MSVC++.NET hingegen gibts leider folgende Fehler:

<ANFANG>
d:cvsrootteststestProject.cpp(108) : error C2782:
'std::mem_fun_ref_wrapper_t<Operation,ObjectType>
std::mem_fun_ref_wrap(const Operation &,Operation::argument_type
(__thiscall ObjectType::* )(void))' : template parameter 'ObjectType' is
ambiguous
d:cvsrootteststestProject.cpp(86) : see declaration of
'std::mem_fun_ref_wrap'
could be 'const MyStruct'
or 'MyStruct'
d:cvsrootteststestProject.cpp(108) : error C2785:
'std::const_mem_fun_ref_wrapper_t<Operation,ObjectType>
std::mem_fun_ref_wrap(const Operation &,Operation::argument_type
(__thiscall ObjectType::* )(void) const)' and '<Unknown>' have different
return types
d:cvsrootteststestProject.cpp(79) : see declaration of
'std::mem_fun_ref_wrap'
d:cvsrootteststestProject.cpp(116) : error C2782:
'std::mem_fun_ref_wrapper_t<Operation,ObjectType>
std::mem_fun_ref_wrap(const Operation &,Operation::argument_type
(__thiscall ObjectType::* )(void))' : template parameter 'ObjectType' is
ambiguous
d:cvsrootteststestProject.cpp(86) : see declaration of
'std::mem_fun_ref_wrap'
could be 'const MyStruct'
or 'MyStruct'
d:cvsrootteststestProject.cpp(116) : error C2785:
'std::const_mem_fun_ref_wrapper_t<Operation,ObjectType>
std::mem_fun_ref_wrap(const Operation &,Operation::argument_type
(__thiscall ObjectType::* )(void) const)' and '<Unknown>' have different
return types
d:cvsrootteststestProject.cpp(79) : see declaration of
'std::mem_fun_ref_wrap'
d:cvsrootteststestProject.cpp(124) : error C2782:
'std::mem_fun_ref_wrapper_t<Operation,ObjectType>
std::mem_fun_ref_wrap(const Operation &,Operation::argument_type
(__thiscall ObjectType::* )(void))' : template parameter 'ObjectType' is
ambiguous
d:cvsrootteststestProject.cpp(86) : see declaration of
'std::mem_fun_ref_wrap'
could be 'const MyStruct'
or 'MyStruct'
d:cvsrootteststestProject.cpp(124) : error C2785:
'std::const_mem_fun_ref_wrapper_t<Operation,ObjectType>
std::mem_fun_ref_wrap(const Operation &,Operation::argument_type
(__thiscall ObjectType::* )(void) const)' and '<Unknown>' have different
return types
d:cvsrootteststestProject.cpp(79) : see declaration of
'std::mem_fun_ref_wrap'
<ENDE>

Meine Fragen nach Priorität:

1. Was muss ich anders machen, damit der MSVC das ganze kapiert.
2. Ist der Code so korrekt und MSVC zu pingelig oder ist der gcc zu
tolerant (und rät gut)
3. Lässt sich mem_fun_ref_wrapper_t durch standard functionsobjekte
(eher aus einer Kombination derselben) aus der STL ersetzen?

Hier kommt das Programm:

<ANFANG>
#include <iostream>
#include <vector>
#include <cmath>
#include <sstream>
#include <cassert>

#include <algorithm>
#include <iterator>
#include <functional>

class MyStruct
{
public:
MyStruct( int i=100 ) : m_i(i) {}
int number() const { return m_i; }
private:
int m_i;
};

std::ostream& operator<<( std::ostream& out, const MyStruct& ms )
{
out << ms.number();
return out;
}

namespace std
{
template OutputIter copy_if( InputIter b, InputIter e, OutputIter dest,
Predicate Pred )
{
while( b != e )
{
if( Pred(*b) )
{
*dest = *b;
++dest;
}
++b;
}
return dest;
}

template<class Operation, class ObjectType>
struct mem_fun_ref_wrapper_t : public
std::unary_function<ObjectType,typename Operation::result_type>
{
mem_fun_ref_wrapper_t( const Operation& op, typename
Operation::argument_type (ObjectType::*funcPtr)() ) :
m_op(op),
m_funcPtr(funcPtr)
{}

typename Operation::result_type operator()( ObjectType& ref )
{
return m_op( (ref.*m_funcPtr)() );
}

Operation m_op;
typename Operation::argument_type (ObjectType::*m_funcPtr)();
};

template<class Operation, class ObjectType>
struct const_mem_fun_ref_wrapper_t : public
std::unary_function<ObjectType,typename Operation::result_type>
{
const_mem_fun_ref_wrapper_t( const Operation& op, typename
Operation::argument_type (ObjectType::*funcPtr)() const ) :
m_op(op),
m_funcPtr(funcPtr)
{}

typename Operation::result_type operator()( const ObjectType& ref )
{
return m_op( (ref.*m_funcPtr)() );
}

Operation m_op;
typename Operation::argument_type (ObjectType::*m_funcPtr)() const;
};

template<class Operation, class ObjectType> inline
const_mem_fun_ref_wrapper_t<Operation,ObjectType>
mem_fun_ref_wrap( const Operation& op, typename
Operation::argument_type (ObjectType::*mf)() const )
{
return const_mem_fun_ref_wrapper_t<Operation,ObjectType>(op, mf );
}

template<class Operation, class ObjectType> inline
mem_fun_ref_wrapper_t<Operation,ObjectType>
mem_fun_ref_wrap( const Operation& op, typename
Operation::argument_type (ObjectType::*mf)() )
{
return mem_fun_ref_wrapper_t<Operation,ObjectType>(op, mf );
}

}

int main(int argc, char* argv[])
{
int array[] = {0,1,2,3,4,5,6,7,8,9,10};

std::vector<MyStruct> myNumbers;
std::copy( array, array+10, std::back_inserter(myNumbers) );

std::cout << "Array: ";
std::transform( myNumbers.begin(), myNumbers.end(),
std::ostream_iterator &MyStruct::number ) );
std::cout << std::endl;

std::cout << "Greater 2: ";
std::copy_if( myNumbers.begin(),
myNumbers.end(),
std::ostream_iterator std::mem_fun_ref_wrap( std::bind2nd( std::greater<int>(), 2),
&MyStruct::number )
);
std::cout << std::endl;

std::cout << "Less 2: ";
std::copy_if( myNumbers.begin(),
myNumbers.end(),
std::ostream_iterator std::mem_fun_ref_wrap( std::bind2nd( std::less<int>(), 2),
&MyStruct::number )
);
std::cout << std::endl;

std::cout << "Equal 2: ";
std::copy_if( myNumbers.begin(),
myNumbers.end(),
std::ostream_iterator std::mem_fun_ref_wrap( std::bind1st( std::equal_to<int>(), 2),
&MyStruct::number )
);

std::cout << std::endl;
}

Besten Dank,
Maxim

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Markus Schaaf · Guest

"Maximilian Hrabowski" <spam (AT) clausmark (DOT) com> schrieb:

M. Hrabowski · Guest

Markus Schaaf wrote:

Maximilian Hrabowski · Guest

ok, dass man den namespace std nicht erweitern darf war mir nicht bekannt.
Ich habe den namespace, in dem die betreffenden Teile stehen mal in
"std2" geändert.

Das Hauptproblem, nämlich das ich besagten Code am Ende meines ersten
Postings mit MSVC nicht compiliert bekomme, ist leider dasselbe
geblieben und blieb dadurch unbeeinflusst.

Markus Schaaf · Guest

"Maximilian Hrabowski" <spam (AT) clausmark (DOT) com> schrieb:

Maximilian Hrabowski · Guest

Markus Schaaf wrote: