3. [Gelöst] Rückgabewert: Vektor

[Gelöst] Rückgabewert: Vektor

  • N

    Hallöchen 🙂

    (und schon wieder ein Problemchen mit mir xD)

    Ich frage mich ob ich als return-Wert auch einen Vektor setzen kann?
    Folgendes habe ich schon fabrizieren können:

    #include <iostream>
#include <vector>

using namespace std;

int main(){
	int v1[3];
	int v2[3];
	int* change(int* v1);

	v1[0] = 1;
	v1[1] = 2;
	v1[2] = 3;

	change(v1);

	for (int i = 0; i < 3; i++){
		cout << v2[i] << " ";
	}

	system("Pause");

}

int* change(int* v1){

	int  v2[3];
	v2[0] = v1[2];
	v2[1] = v1[1];
	v2[2] = v1[0];

	return v2;
}

    Klar, das bei der Ausgabe die min-Werte herauskommen für v2; ich habe v2 ja initialisiert.

    Wie bekomme ich aber mein eigentliches Anliegen hin?
    Dass ich eben den v2-Vektor mit der change-Methode befüllen kann?

    Vielen lieben Dank schon einmal für eure Hilfe 🙂
    (ich hoffe es ist verständlich >__<)

    Liebe Grüße,
    Norchen

    0
  • Mod

    Dein Code ist voller tödlicher Fehler, reine Glückssache, wenn der macht was du möchtest.

    Mit vector kannst du umgehen wie mit jedem anderen Datentyp auch (außer Arrays für die Sonderregeln gelten auf die du auch prompt reingefallen bist), das heißt du kannst ihn per return aus der Funktion herauskopieren oder per Referenz direkt ändern. Du scheinst allgemein aber Schwierigkeiten mit den Grundlagen (nicht nur von Arrays) von Gültigkeitsbereichen und Funktionsargumenten zu haben. Da solltest du zuerst einmal Nachholen.

    0
  • R
     

    int* change(int* v1){

    int  v2[3];
    v2[0] = v1[2];
    v2[1] = v1[1];
    v2[2] = v1[0];

    return v2;
}

    Wie gesagt ist dies absolute Glückssache, da v2 auf dem Stack abgelegt wird, und dieser nach Rücksprung aus der Funktion wieder bereinigt wird. Dein Compiler sollte dir aber auch eine fette Warnung ausspucken.

    Mit vector würde ich es wie folgt machen:

    void change( std::vector<int> &result, const int *v1 ) {
    result[0] = v1[0];
    result[1] = v1[1];
    result[2] = v1[2];
}

    Wenn du auf normale arrays bestehst wie folgt:

    void change(int *result, const int *v1) {
    result[0] = v1[0];
    result[1] = v1[1];
    result[2] = v1[2];
}

    "Care must be taken not to exceed the array boundaries."

    0
  • T

    @RedPuma
    Deine Methoden sind auch nicht unbedingt besser. Die Anzahl der Elemente der Vectoren/ Arrays werden gar nicht berücksichtigt.

    @Norchen
    Du hast in deinem Fall grundsätzlich drei Optionen:
    1. Die „alte“ Übergabe per Pointer + Größe ( funktioniert mit Vectoren und Arrays )

    void foo( int* massiv, size_t größe )
{
    // Überprüfen was hier angekommen ist.
    // ..dann die eigenen Elemente „zählen“
    // ..und dann, so weit es passt, füllen.
}

    2. Per Reference ( funktioniert nur mit Objekten )

    void foo( std::vector< int >& massiv )
{
    // Überprüfen was hier angekommen ist. ( massiv.size() )
    // .. oder halt first != last sehe die Möglichkeit Nummer 3
    // ..dann die eigenen Elemente „zählen“
    // ..und dann, so weit es passt, füllen.
}

    3. First und Last Iterator ( geht mit beiden )

    template< typename T_Iter >
void foo( T_iter first, T_iter last )
{
    // Überprüfen was hier angekommen ist. ( while ( first != last ) )
    // ..dann die eigenen Elemente „zählen“
    // ..und dann, so weit es passt, füllen.
}

    oder halt ganz speziell für dein Fall:

    void foo( std::vector< int >::iterator first,
          std::vector< int >::iterator last )
{
    // Überprüfen was hier angekommen ist. ( while ( first != last ) )
    // ..dann die eigenen Elemente „zählen“
    // ..und dann, so weit es passt, füllen.
}

    Die dritte Möglichkeit ist IMHO die bessere von 3, weil sie auch STL-conform ist.

    Natürlich kann man generell einen vector oder ein Objekt einfach so per copy/move zurückgeben..

    std::vector< int > t = foo(...);
    0
  • N

    Vielen Dank für die schnellen Antworten.

    Ich glaube, ich habe mit dem Beispiel einfach nicht den Kernpunkt verdeutlicht, sondern nur "Mist" gemacht.

    @Travor: Vielen Dank! Ich werde mir das mal in einer ruhigen Minute zu gemüte führen, ich glaube als Übung für mich schadet das nicht.

    Eigentlich ging es nur darum was geschehen muss um einen "Vektor" in dem Falle dann (wohl) einen Pointer als return-Wert zu haben.
    Ich glaube, ich habe das dermaßen umständlich erklärt... Tut mir leid 😣
    (aber ich dachte mit Beispiel ist immer gut...)

    Mittlerweile hatte sich das Problem auf Arbeit gelöst.
    (Blöd, wenn man kein C++ (komplett) beherrscht und nen Code aufräumen soll.. -.-")
    Er gitb nun auch das zurück was ich will; es muss halt nur über allso benannt werden.

    Vielen Dank nochmal >.<"

    0
  • Mod

    Ehrlich gesagt klingt das so, als hättest du Mist gemacht. Globale Variablen und/oder Rückgabe von funktionslokalen Objekten lese ich aus deiner Beschreibung heraus. Es ist nur eine Frage der Zeit, bis das explodiert.

    Im anderen Thread klingt es auch nicht besser. Du hast die Antworten dort anscheinend nicht wirklich verstanden, da dir der nötige Hintergrund einfach fehlt. Aber ein Chef, der jemand total Ungeschulten unter Zeitdruck auf Pointergefrickel loslässt, hat's irgendwie auch nicht anders verdient.

    0
Anmelden zum Antworten