c++, STL Grundlagen. Konkrete Frage

[lerner (Gast)]

Hallo ich habe folgende Frage. Es steht im Grunde als Kommentar im Code.
Bei mir steht der Versuch ins Haus nach 15 Jahren c auf c++ zu 
erweitern.

Die Lernkurve wird glaube ich unterschätzt wenn man von Objekten und der 
ganzen Denkweise nicht beherrscht wird. Ich glaube das ganze wirkt so 
mächtig, dass man auch gut mal zu viel erhofft. Vielleicht geht es mir 
grad so.
Dazu neue Syntax, neue Bibliotheken... Dennoch werde ich es wagen und 
frage mal ganz einfach heraus, wer Rat weiß.

#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>


//Fragen:
//Kann man PrintIntVector so umschreiben, dass es ein PrintIntContainer ist, also merkt wenn es z.B. ein deque wäre?
//Kann man PrintIntVector (oder PrintIntContainer) so schreiben, dass es auch für double oder andere Typen geht?
//Oder wie würde das gehen. eine Print Klasse mit überladenen Funktionen wäre ja nicht universiell
static void PrintIntVector( std::vector<int> &cont )
{
    for( std::vector<int>::iterator cont_it =cont.begin(); cont_it != cont.end(); cont_it++)
    {
        std::cout << *cont_it << " ";
    }
    std::cout << std::endl;
}

int main()
{
    std::vector<int> cont;

    std::vector<double> cont2;       //So wenn ich da jetzt was reinlege und auch über eine Print Funktion ausgeben möchte?
    //std_vector<my_class> cont3;    //Oder gar da?? Geht das überhaupt?
    std::deque<int> cont4;           //Sogar ints...gibt es da eine universielle Methode für ein PrintWhatIwant?


//Container füllen
    for(int n=0; n<20; n++) {
        cont.push_back(n);

        cont4.push_back(n);         //Kann ja SO jetzt nicht einfach peglottet werden
        cont2.push_back( (double)n );
    }
    PrintIntVector(cont); //Oder lieber PrintVector() oder noch lieber PrintContainer....

//durcheinander bringen
    std::random_shuffle(cont.begin(), cont.end());
    PrintIntVector(cont);

//wieder sortieren
    std::sort(cont.begin(), cont.end());
    PrintIntVector(cont);

    return 0;
}

[J. Eder (Gast)]

Ich würde es mal über ein Funktionstemplate probieren
(Hier gibt es eine gute Beschreibung dazu: 
www.cpp-tutor.de/cpp/le15/funk_templ.html)

[Tom (Gast)]

>[function templates]
Dann wirst Du für den Iterator das hier brauchen:
http://en.wikipedia.org/wiki/Typename#A_method_for_indicating_that_a_dependent_name_is_a_type

>   //std_vector<my_class> cont3;    //Oder gar da?? Geht das überhaupt?
Ja. http://msdn.microsoft.com/de-de/library/1z2f6c2k.aspx


Falls du C++11 benutzen kannst, sieh dir auch range based for loops 
statt iterator an.

[nicht"Gast" (Gast)]

moin

probier mal

template<class T>
void Print(const T &toPrint){    
  std::copy(toPrint.begin(), toPrint.end(),std::ostream_iterator<T::value_type>(std::cout, " " ));
  std::cout << "\n";
}

braucht noch #include <iterator>


Grüße,

[Rolf M. (rmagnus)]

lerner schrieb:
> //Fragen:
> //Kann man PrintIntVector so umschreiben, dass es ein PrintIntContainer
> ist, also merkt wenn es z.B. ein deque wäre?
> //Kann man PrintIntVector (oder PrintIntContainer) so schreiben, dass es
> auch für double oder andere Typen geht?

Beides läßt sich machen, indem man aus der Funktion ein Template macht.
Übrigens: Da du den Container in der Funktion nicht änderst, sollte die 
Referenz darauf const sein und mit einem const_iterator durchlaufen 
werden. In C wird const sehr lax gehandhabt. In C++ ist das anders, 
daher solltest du immer auf const-korrekte Programmierung achten, d.h. 
alles const machen, was nicht verändert wird.

So würde die Funktion als Template aussehen: (ungetestet)

[C]
template <typename Container>
void PrintContainer(const Container& cont)
{
    for(Container::const_iterator cont_it =cont.begin(); cont_it != 
cont.end(); cont_it++)
    {
        std::cout << *cont_it << " ";
    }
    std::cout << std::endl;
}

>     std::vector<double> cont2;       //So wenn ich da jetzt was reinlege
> und auch über eine Print Funktion ausgeben möchte?
>     //std_vector<my_class> cont3;    //Oder gar da?? Geht das überhaupt?

Ja das geht, wenn du für my_class einen operator<< definierst, in dem 
festgelegt wird, wie dein Objekt ausgegeben werden soll.

[Klaus W. (mfgkw)]

template< class CONTAINER >
void PrintWhatIWant( const CONTAINER &cont )
{
  for( typename CONTAINER::const_iterator iCont=cont.begin(); iCont!=cont.end(); ++iCont )
  {
    std::cout << (*iCont) << " ";
  }
  std::cout << std::endl;
}

Das ist i.W. der Vorschlag von Rolf Magnus, aber er funktioniert (dank 
des typename in der for-Schleife).

[Rolf M. (rmagnus)]

Ah richtig. Dependant types... da hatte ich nicht dran gedacht.

[Plauzi (Gast)]

template< class CONTAINER >
void PrintWhatIWant(const CONTAINER &cont)
{
  for(auto iCont = begin(cont); iCont != end(cont); ++iCont) {
    std::cout << (*iCont) << " ";
  }
  
  std::cout << std::endl;
}

[Rolf M. (rmagnus)]

Übrigens:

> CONTAINER

würde ich nicht als Name für den Template-Parameter verwenden, da 
komplett groß geschriebene Namen üblicherweise für Makros reserviert 
werden.

Plauzi schrieb:
> template< class CONTAINER >
> void PrintWhatIWant(const CONTAINER &cont)
> {
>   for(auto iCont = begin(cont); iCont != end(cont); ++iCont) {
>     std::cout << (*iCont) << " ";
>   }
>
>   std::cout << std::endl;
> }

Wenn schon C++11, dann kann man auch gleich noch einen Schritt weiter 
gehen:

template<class Container>
void PrintWhatIWant(const Container& cont)
{
    for(const auto& element: cont)
    {
        std::cout << element << " ";
    }
    std::cout << std::endl;
}

[Klaus W. (mfgkw)]

Rolf Magnus schrieb:
> Übrigens:
>
>> CONTAINER
>
> würde ich nicht als Name für den Template-Parameter verwenden, da
> komplett groß geschriebene Namen üblicherweise für Makros reserviert
> werden.

naja, der gängigste Nme für Templateparameter ist T ...

[lerner (Gast)]

Einen herzlichen Dank erst mal an alle.
Ich hoffe ich finde am Wochenende etwas Zeit um mir eure posts zu 
verinnerlichen.