Container als Rückgabewert



  • Hallo bin relativ neu hier,

    meine Frage ist wie ich einen Container mit mehreren Parametern zurückgebe. Wenn ich einen Vector mit nur einem Datensatz zurückgebe, dann funktioniert es.

    z.B.

    std::vector<std::string> irgendwas::bla(std::string path) {
     std::vector<std::string>b;
     b.push_back("hi");
     b.push_back("ciao");
    
     return b;
    }
    

    Wie mache ich das mit mehreren Parametern? also std::vectorstd::string,std::string.

    Oder wie gebe ich ein struct zurück? Bestimmt kommt die Antwort, dass ich das über eine Referenz machen solle, aber wenn ich den Container als private deklariere funktioniert das dann überhaupt?



  • strurct MyStruct
    {
        std::string name;
        int idx;
        double weight;
    };
    
    MyStruct create()
    {
        MyStruct ms;
        // ...
        return ms;
    }
    
    std::vector<MyStruct> create(std::size_ t n)
    {
        std::vector<MyStruct> vec(n);
        // ...
        return vec;
    }
    


  • ok, was ist da n? Der eigentlich Sinn des Programms ist das ich eine Datei übergebe und die struct bzw. der container die werte wie größe, typ etc. zurückgeben soll. Kann ich da den struct variablen direkt funktionen zuweisen?



  • Und wenn ich das als methode mache, wie sieht der prototyp für die letzte funktion aus?

    std::vector<struct> a::a(std::string)
    

    ? Und wie kann ich das realisieren, wenn ich die struct oder vector als private deklariere? und zurückgeben möchte?



  • Du sprichst leider ziemlich in Rätseln, für mich jedenfalls.

    Erstmal zur Terminologie:
    - Ein Container (z.B. ein vector) hat einen Typparameter, nämlich des Typs, welchen er speichern soll. Das kann bei einem Vector nur GENAU einer sein!
    - Ein vector mit Typparamter, z.B. ein std::vectorstd::string, hat dann beliebig viele Datensätze (nämlich so viele, wie du haben magst oder reinsteckst). Übergibst du dem Konstruktor des vectors eine ganze Zahl, dann ist das die Größe (nicht Capacity, wie z.B. in Java), die der Vector zu Beginn haben wird.
    - Eine Struktur (struct!) kann im Gegensatz dazu (beliebig) viele beliebige Member (oder synonym Attribute oder Eigenschaften) haben. Und auchd a sind die Typen egal: Egal ob das PODs (wie in, bool, double, char etc.) sind oder ob das Zeiger (auch Funktionszeiger sind ok) oder ganze andere Strukturen doer Klassen sind.
    - Klassen sind dasselbe wie structs, nur dass die Standardsichtbarkeit private statt public ist. In structs wie auch in Klassen kann man natürlich auch Operationen, sprich Methoden (oder synonym Memberfunktionen), deklarieren&definieren.
    - Möchtest du nun mehrere Datenzurückgeben bieten sich dir 2 Möglichkeiten:
    + Die Daten sind homogen und quasi gleichzubehandeln, dann nutz einen Container der eine Reihe dieser Daten enthält (z.B. du fragst einen Ordner was er für Dateien, d.h. z.B. deren Namen, beinhaltet, dann gibst du einen vector von strings zurück -> std::vectorstd::string getFilename(std::string const& directory);)
    + Du hast inhomogene Daten, die logisch zusammen gehören, aber eben komplett unterschiedlich sind. Beispiel: Deine Funktion erwartet einen Dateinamen (std::string) und soll die Eigenschaften(Größe, Dateiendung, Schreib-/Leserechte, Inhalt, etc.) dieser Datei zurückgeben. Dann baust du eine Struktur/Klasse, die dieses Konzept modelliert und abstrahiert darstellt:

    struct FileProperty
    {
    	std::string path;
    	std::size_t size;
    	int rights;
    	char* content;
    };
    

    Und in einer Funktion, die diese Eigenschaften ausliest kannst du solch ein (Sinnvoll gefülltes) Struct dann zurückgeben:

    FileProperty readProperties(std::string const& path)
    {
    	FileProperty prps;
    
    	prps.path = path;
    	prps.size = 1337;
    	prps.rights = 577;
    	// ...
    
    	return prps;
    }
    

    Und natürlich kannst du auch beides miteinander kombinieren und einen Contaienr voll solcher FileProperty objekte zurückgeben.

    War das halbwegs verständlich?

    *: Beliebig heisst wortwörtlich soviele du magst, mit dem Ausschluss, dass Unendlichkeit bei COmputern ja immer etwas knapp beim Speicher wird 😉



  • chris01349 schrieb:

    Der eigentlich Sinn des Programms ist das ich eine Datei übergebe und die struct bzw. der container die werte wie größe, typ etc. zurückgeben soll.

    Den Begriff "Conainer" benutzen wir in C++ eigentlich nur für homogene Anhäufungen, wo alle Elemente von demselben Datentyp sind. Das, was Du willst, klingt eher nach etwas anderem. Du willst einen Datentypen haben, der aus mehreren "Komponenten" besteht, die nicht unbedingt von demselben Typ sind, also so etwas wie das, was Skym0sh0 mit "FileProperty" gezeigt hat.

    Alernativ, ginge das auch mit einem Tupel, aber das ist meiner Meinung nach nicht so schön, weil man tuple<string,int,int> vom Typ her nicht ansieht, dass der String für den Dateinamen gedacht ist u.s.w.. Solche "Ad-hoc-Datentypen" sind aber manchmal schon praktisch.


Log in to reply