Geht so etwas in etwa?

#include <deque>
#include <list>
#include <vector>

#include <numeric>

template < typename TContainer<typename T> >
T GetSum(const TContainer &content)
{
	return std::accumulate(content.begin(), content.end(), T());
}

#include <iostream>

int main()
{
	std::vector<int> A(10, 2);
	std::deque<int> B(10, 2);
	std::list<int> C(10, 2);

	std::cout << GetSum(A) << std::endl;
	std::cout << GetSum(B) << std::endl;
	std::cout << GetSum(C) << std::endl;
}

Fehler werden logischerweise in der 7. Zeile angezeigt - ich war der Meinung, so ein Konstrukut hier im Forum schon irgendwann mal gesehen zu haben - leider weiß ich nicht mal mehr ansatzweise, in welchem Thread usw^^
Ähnlich wie in diesem Bsp hier, steht auch in Wirklichkeit T fest, aber ich möchte mich eben nicht auf einen bestimmten Container festlegen...

Danke schon mal : >

bb

template <typename X> class Y

Ich hab jz folgendes gemacht/machen müssen:

#include <numeric>

template<typename T, typename S, template <typename, typename> class TContainer>
T GetSum(const TContainer<T, S> &content)
{
	return std::accumulate(content.begin(), content.end(), T());
}

#include <iostream>
#include <deque>
#include <list>
#include <vector>

int main()
{
	std::vector<int> A(10, 2);
	std::deque<int> B(10, 2);
	std::list<int> C(10, 2);

	std::cout << GetSum(A) << std::endl;
	std::cout << GetSum(B) << std::endl;
	std::cout << GetSum(C) << std::endl;
}

Als ich Ryuzaki s Code-Fragment per copy&paste übernommen hatte, wollte er(MSVC) immer einen allocator<int> ausgeben und hat sich dann (logischerweise) beschwert, dass da kein op<< deklariert ist^^

bb

Hey...

Geht so etwas in etwa? [...]

Jein.

Was du vermutlich suchst ist folgendes:

template <class T, template <class> class Container >
T GetSum(const Container<T> &content)
{
	return std::accumulate(content.begin(), content.end(), T());
}

Problem ist allerdings folgendes:
- du musst beim Template-template parameter (also das was ich hier "Container" genannt hab) alle Templateparameter mit angeben. std::vector z.B. hat mindestens noch den Allokator als zweiten Parameter. Damit hieße das dann z.B.

template <class T, class A, template <class, class> class Container >
T GetSum(const Container<T,A> &content)
{
	return std::accumulate(content.begin(), content.end(), T());
}

Damit ist die Behandlung gleich eingeschränkt, denn damit muss jeder Container mit dem du die Funktion benutzen willst, genau zwei Templateparameter haben. Damit wären wir beim nächsten Thema und einer der Unschönheiten im C++-Standard: die Standardcontainer sind nicht verpflichtet, nur genau die vorgeschriebenen Templateparameter zu haben, der Standard überlässt der Implementierung die Möglichkeit, noch zusätzliche Templateparameter zu definieren. Ein std::vector könnte also durchaus als
`template <class T, class Alloc, class Horst, class Wurstbrot, int barfuss>

class vector;` definiert sein. Und der passt natürlich wieder nicht auf den template-templateparameter. Ich würde sowas daher eher wie folgt machen:

template <class Container>
typename Container::value_type GetSum(Container const& cont);

naja - das thema mit "der standard schreibt die anzahl der template-parameter nicht vor" hatten wir schon mal und waren recht gespaltener Meinung dazu.

Naja, dann fällt halt die Überprüfung für den value_type weg, da man mit StaticAssert und typeid ja nicht all zu viel anfangen kann...
ist auch nicht so wichtig.

Danke : >

naja - das thema mit "der standard schreibt die anzahl der template-parameter nicht vor" hatten wir schon mal und waren recht gespaltener Meinung dazu.

Naja. Er schreibts eben nicht vor. Das ist keine Meinung sondern Tatsache Wie viele Bibliotheksimplementierungen das dann ausnutzen und tatsächlich weitere Parameter einführen steht auf einem anderen Blatt und war IIRC der strittige Bestandteil der Diskussion.

Naja, dann fällt halt die Überprüfung für den value_type weg, da man mit StaticAssert und typeid ja nicht all zu viel anfangen kann...
ist auch nicht so wichtig.

Was für eine Überprüfung denn? Kann man sicher trotzdem noch einbauen.

[...] die Standardcontainer sind nicht verpflichtet, nur genau die vorgeschriebenen Templateparameter zu haben, der Standard überlässt der Implementierung die Möglichkeit, noch zusätzliche Templateparameter zu definieren.

Da gab es ja neulich eine große "Interpretations-Debatte" zu dem Thema. Wenn man sich den Beitrag von Old McDonald anschaut, findet man den Link zu http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#94 in der genau das diskutiert wird.

edit:

Allerdings kann ich dem Text auch nicht ganz entnehmen, wie es gemeint war, was die neue Intention ist und was C++0x daraus macht.

Gruß,
SP

Da gab es ja neulich eine große "Interpretations-Debatte" zu dem Thema. Wenn man sich den Beitrag von Old McDonald anschaut, findet man den Link zu http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#94 in der genau das diskutiert wird. Fazit: Eine Standardbibliothek, die zusätzliche default-Template-Parameter für Klassen benutzt ist nicht standardkonform.

Gut zu wissen. Das macht die Situation allerdings für unskilled's GetSum nicht viel besser, zumal std::set auf jeden Fall drei Parameter hat und selbstgestrickte Container nicht unbedingt mehr als einen.

btw: Ich habe meinen vorherigen Beitrag editiert.

template <class Container>
typename Container::value_type GetSum(const Container& content)
{
    return std::accumulate(content.begin(), content.end(), typename Container::value_type());
}

template <
	typename TChar,
	typename TTraits  = std::char_traits< TChar >,
	typename TAlloc   = std::allocator< typename TTraits::char_type >,
	template <
		typename, typename
	> class TArray    = std::deque
>
class basic_string
{};

bb