[halp!] C++ Funktionstemplate für Ausgabe multidimensionaler Vectoren

[mcuncool]

Mkay, also ich habe das hier zusammengebastelt:

template <typename T>
void printMultiVector(std::vector<std::vector<T>> &v){
    for (int i=0; i<v.size();i++){
		for(int j=0;j<v[i].size();j++){
			std::cout << v[i][j] << " ";
		}
		std::cout << endl;
		
    }
	std::cout << endl;
}

Ich bin ein noob in C++, geschweige generische Programmierung in C++
und ich werde das Gefühl net los, dass:

a) das irgendwie totaler Schwachsinn ist
b) das besser gehen muss

andererseits erfüllt es seinen Zweck(&verkürzt meinen Code) was mich SEHR erfreut. Bin für jeden Input dankbar: Stil, Semantics, Verweise, Verbesserungen, Suche nach dem Sinn des Lebens etc.

[snow]

Die generische Programmierung kenne ich auch nicht in der Tiefe als dass ich da großartig was verbessern könnte, aber die Iteration würde ich evtl. Iteratoren (evtl. auch direkt std::for_each) oder die C++11 for-Schleife nutzen ( for (auto& i : v) { for (auto& j : i) { std::cout << j << " "; } } ).
Großartig was verbessern an den Durchläufen an sich kann man nicht, das ist immer i*j. :/

Als Template-Parameter kannst du auch rein theoretisch direkt std::vector<std::vector<type>> übergeben, wenn du sicher stellst, dass dein Typ im ersten Vector immer einer ist, der iteriert werden kann.

[Master674b]

Wüsste spontan nicht, wie man das einfacher machen könnte. Höchstens so:

template <typename T>
void print_2d_container(const T& container) {
    for (const auto& y: container) {
        for (const auto& x: y)
            std::cout << x << ' ';
        std::cout << std::endl;
    }
}

Edit: zu langsam

[Schlüsselbein]

Ggf sowas in der Art:

template<typename T>
void cout_container(const T& cont)
{
	for(auto& c : cont)
	{
		std::ostream_iterator<T::value_type::value_type> out(std::cout, "\n");
		std::copy(c.begin(), c.end(), out);
	}
}

[Master674b]

Originally Posted by Schlüsselbein

Ggf sowas in der Art:

template<typename T>
void cout_container(const T& cont)
{
	for(auto& c : cont)
	{
		std::ostream_iterator<T::value_type::value_type> out(std::cout, "\n");
		std::copy(c.begin(), c.end(), out);
	}
}

Hier könnte man das argument statt als const ref auch by value übergeben und über std::move in std::cout moven, das wäre noch effizienter im fall das cont ein temporary ist.

template <typename T, typename Strm>
void move_2d_container_to_strm(T container, Strm& strm) {
    for (auto& c: container) {
        std::ostream_iterator<T::value_type::value_type> out_it(strm, " ");
        std::move(std::begin(c), std::end(c), out_it);
        strm << std::endl;
    }
}

Damit würde das ganze noch move semantics benutzen, sprich falls container ein ivalue objekt ist -> copy, sonst move.

[Raz9r]

Man sollte übrigens, um den seltenen Fall eines vector<bool> zu behandeln, folgendes benutzen:

for (auto &&elem : container) ...

[Schlüsselbein]

Wer vector<bool> benutzt, gehört bestraft