template <typename ListenTyp, typename ElementTyp> ListenTyp<ElementTyp> removeEltFromList(ElementTyp elt, ListenTyp<ElementTyp> liste)

wie geht das richtig?

template <typename ListType, typename ElementType> inline ListType<ElementType> remove(ElementType elt, const ListType<ElementType>& v1)
{
	ListType result;
	for (const ElementType ListElt: v1)
        if (ListElt != elt)
            result.push_back(ListElt);
	return result;
}

template <template <typename> ListenTyp, typename ElementTyp> ListenTyp<ElementTyp> removeEltFromList(ElementTyp elt, ListenTyp<ElementTyp> liste)

Wobei ich es so besser finden würde:

template <typename ListenTyp> typename ListenTyp::ElementTyp removeEltFromList(typename ListenTyp::ElementTyp elt, ListenTyp& liste)

Oder analog über Traits. Denn dann beschränkst du die Argumentliste von ListenTyp nicht.
Ich frag mich allerdings warum das keine Memberfunktion deiner Liste ist.

template<class ElementType, template<class> class ListType>
ListType<ElementType> foo(ElementType, ListType<ElementType>)

Aber das ist doof, weil das dann nur mit Listentypen mit genau einem Templateparameter funktioniert. Wenn das z.B. mit vector, deque und anderen zweiparametrigen Templates gehen soll, braucht man schon:

template<class ElementType, template<class, class> class ListType>
ListType<ElementType, std::allocator<ElementType> > foo(ElementType, ListType<ElementType, std::allocator<ElementType> >)

Du siehst, das ist sehr speziell und der ganze Zweck von Templates geht verloren.

Daher klassisch:

template <typename ListenTyp, typename ElementTyp> ListenTyp foo(ElementTyp, ListenTyp)

Außerdem würde ich darüber nachdenken, so einer Funktion eine Schnittstelle mit Iteratoren zu verpassen.

Außerdem würde ich darüber nachdenken, so einer Funktion eine Schnittstelle mit Iteratoren zu verpassen.

Geht irgendwie nicht ... "ListenTyp" is not a template.

typename -> class?

Das ist egal. Schau nochmal was genau wir oben geschrieben haben

typename -> class?

Ähhhh, vielleicht solltest du nochmal mit den Grundlagen von Templates anfangen, bevor du kompliziertere Sachen baust. Da das Thema zu groß für einen Forenbeitrag ist: Buch schnappen.

PS: Iterator++

Falls das immer der gleiche huuuu mit egal wie vielen uuuus ist, noch ein weiterer Tipp: Versuch nicht in C++ Lisp zu programmieren. Das scheitert schon immer grandios, wenn Java-Programmierer in C++ versuchen Java zu programmieren, dabei besteht zwischen Java und C++ zumindest eine gewisse Ähnlichkeit. Das ist in keiner Sprache eine gute Idee, sich von den bewährten Prinzipien weg zu bewegen.
Daher: Die STL ist aus gutem Grund mit Iteratoren implementiert, eben weil der Ansatz den Listentyp als ganzes zu übergeben Mist ist. Du kannst vielleicht noch darüber streiten, ob Iteratoren oder Ranges besser sind. Oder ein ganz neues Prinzip. Aber dazu müssen diese Prinzipien erst einmal mindestens genauso flexibel wie Iteratoren sein, dann kann man darüber reden.

template<class Container, class Function>
Function for_each(Container container, Function function)
{
  return for_each(begin(container), end(container), function);
}

Aber bevor man anfängt mit Templates als Templateparameter rumzuwurschteln..

Wobei ich ja so eine Überladung schon nett finden würde:
[...]

Also die C++11 range-based loops?

template
<
    template <typename> class foo
    typename bar
>

heißen, wobei statt des typenames auch class verwendet werden kann. Das class ist allerdings Pflicht.

Also die C++11 range-based loops?

Ok, foreach war vielleicht ein schlechtes Beispiel, weil man das eigentlich eh vergessen kann. (Sobald Microsoft sich mal gnädig zeigt und die range-based Loops dann auch implementiert..)
Aber den anderen Algorithmen würde eine Überladung der man einfach den Container übergeben kann auch nicht schaden.

Statt

std::remove_if(std::begin(container), std::end(container), [] (const Element &element) { return element.foo(); });

Kommt dann:

std::remove_if(container, [] (const Element &element) { return element.foo(); });

std::remove_if (const Element& element : container) {
  return element.foo();
}

...

std::begin(container)
  std::end(container)

Mal so am Rande: Ich weiß nicht, ob das so eine gute Idee ist, begin/end zu qualifizieren. Bei swap tue ich das jedenfalls nicht, nicht in generischem Code. Mit der Qualifizierung schaltest Du nämlich ADL aus.

Mal so am Rande: Ich weiß nicht, ob das so eine gute Idee ist, begin/end zu qualifizieren. Bei swap tue ich das jedenfalls nicht, nicht in generischem Code. Mit der Qualifizierung schaltest Du nämlich ADL aus.

Ich weiß, so ganz einig bin ich mir auch nicht. Aber Arrays kommen leider nicht aus std::. Alles etwas suboptimal. Operatoren hätten ja nicht geschadet, aber ich glaube das hatten wir sogar schon mal. Ja, genau: http://www.c-plusplus.net/forum/294688