Beispiel: Ein std::set mit mehreren std::string . Nun brauche ich aber nur die Strings, deren Länge genau 6 ist und die nur aus Ziffern bestehen.

1. Versuch: Zuerst dachte ich an eine Funktion, die beliebig viele std::function entgegennehmen kann, mittels variadic templates . Das ging aber nicht, weil VS 2012 das nicht unterstützt (ich habe nur VS 2012 zur Verfügung).

2. Versuch: std::tuple mit beliebig viele std::function , wobei durch _VARIADIC_MAX 10 simuliert wird. Da hatte ich dann das Problem, dass ich nicht über std::tuple iterieren kann, weil I in std::get<I> nicht zur Compilezeit bekannt ist.

3. Versuch: Alle std::function in einen std::vector stecken:

#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <iterator>
#include <set>
#include <string>
#include <vector>
using namespace std;

bool correct_length( const std::string& str )
{
	return str.length()==6;
}

bool only_digits( const std::string& str )
{
    return all_of( begin(str), end(str), isdigit );
}

template <typename InputIterator, typename OutputIterator, typename Functions>
void copy_needed(  InputIterator first, InputIterator last, OutputIterator result, const Functions& functions )
{
	while( first!=last )
	{
		bool needed = true;
		for(const auto& func : functions)
			needed = needed && func(*first);

		if( needed )
		{
			*result = *first;
			++result;
		}
		++first;
	}
}

int main()
{
	typedef string value_type;

	set<value_type> strs;
	strs.insert( "1x" );
	strs.insert( "12" );
	strs.insert( "123x" );
	strs.insert( "1234" );
	strs.insert( "12345x" );
	strs.insert( "123456" );
	strs.insert( "123456x" );
	strs.insert( "1234567" );

	vector<function<bool(const value_type&)>> functions;
	functions.push_back( function<bool(const value_type&)>(correct_length) );
	functions.push_back( function<bool(const value_type&)>(only_digits) );

	set<value_type> needed_strs;

	copy_needed( begin(strs), end(strs), inserter(needed_strs,begin(needed_strs)), functions );

	for(const auto& str : needed_strs)
		cout << str << '\n';
}

Irgendwie gefällt mir die Lösung aber nicht. Ist die Herangehensweise überhaupt richtig? Hat jemand eine schönere Lösung?

Danke im Voraus.

???

Einen functor/lambda digitslength6 schreiben?

Das geht nicht. Weil ich zum einen eine Funktionen will, die immer nur 1 Aufgabe erledigen und zum anderen, wenn ich 10 Prädikate habe, dann wäre der Functor-Name irgendwann 50 Zeichen lang.

Nathan schrieb:

Einen functor schreiben, der alle Prädikate (ggf. in einem vector) via && verkettet?

Das wäre dann in groppy s Richtung gedacht, das finde ich schon besser ja.

groppy schrieb:

???

Ja das sieht schon besser aus. Schonmal gut, dass mein copy_needed durch copy_if aus der Standardbibliothek abgelöst wird . Allerdings hast du nur 2 Prädikate beachtet. Es könnten auch 5 oder 10 oder nur 1 sein. Ich glaub da bleibt mir echt nur ein Container übrig, in dem ich alle Prädikate sammle. Ohne variadic templates gehts wohl nicht anders?

Man sollte chain noch einen Parameter mitgeben, ob er per && oder || chainen soll und vielleicht kann man sich auf Funktionen festlegen, sodass man std::function nicht mehr braucht.

@groppy: Könnte/würde man bei dir 4 Funktionen so verbinden?

and_combine(and_combine(and_combine(correct_length, only_digits), correct_length), only_digits);

@groppy: Könnte/würde man bei dir 4 Funktionen so verbinden?

and_combine(and_combine(and_combine(correct_length, only_digits), correct_length), only_digits);

Ja, so war das vorgesehen (falls keine variadischen Templates verfügbar).

Sollte sogar durch den Compiler geinlined werden können, was es ungleich schneller macht als deine Variante.

folgendes ist vielleicht von der Syntax her ansprechender:

#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <iterator>
#include <set>
#include <string>

using namespace std;

bool correct_length( const std::string& str )
{
    return str.length()==6;
}

bool only_digits( const std::string& str )
{
    return all_of( begin(str), end(str), isdigit );
}

// --   verknüpft zwei Predicate mit gleichem Argumenttyp zu einem (hier logisch AND)
template< typename T >
std::function< bool( const T& ) > operator&&( const std::function< bool( const T& ) >& f1, const std::function< bool( const T& ) >& f2 )
{
    return [=]( const T& x )-> bool
    {
        return f1(x) && f2(x);
    };
}

int main()
{
    typedef std::string value_type;
    typedef std::function< bool( const value_type& ) > Pred;

    set<value_type> strs;
    strs.insert( "1x" );
    strs.insert( "12" );
    strs.insert( "123x" );
    strs.insert( "1234" );
    strs.insert( "12345x" );
    strs.insert( "123456" );
    strs.insert( "123456x" );
    strs.insert( "1234567" );

    set<value_type> needed_strs;
    copy_if( begin(strs), end(strs), inserter(needed_strs,begin(needed_strs)), 
        Pred(correct_length) && Pred(only_digits)
    );

    for(const auto& str : needed_strs)
        cout << str << '\n';
}

@groppy: Könnte/würde man bei dir 4 Funktionen so verbinden?

and_combine(and_combine(and_combine(correct_length, only_digits), correct_length), only_digits);

Ah ok, so hat er das gemeint. Auch eine nette Idee, ist mir persönlich aber schon ab 3 Prädikaten schon zu unübersichtlich.

@nwp3: Dein Lösung kann ich noch nicht ganz nachvollziehen, da ich std::forward noch nicht wirklich kenne. Muss ich mir noch genauer anschauen.

@Werner: Deine Lösung gefällt mir am besten, die werde ich verwenden. Den operator&& zu überladen, auf die Idee wäre ich wohl nie gekommen .

Danke euch allen