ich habe ein Problem. Und zwar habe ich eine Klasse, die eine Funktion hat, die einkommende Zahlenpaare der Form(Id =6, Ergebnis = in einen Vektor einsortiert.

Jetzt will ich, dass der Vektor zurückgegeben wird, damit ich mir ihm an andere STelle des Programms in einer anderen Funktion einer anderen Klasse weiterarbeiten kann. Geht das?

struct Ergebnis {
  int ID;
  double Wert;
};

class Speichern
{
  ??? storeResult (int ID, double Ergebnis);
  Ergebnis <int> dieBesten[3];
}

??? Speichern::storeResult (int id, double wert) {

//Vektor wird gefüllt

return //den gesamten Vektor mit Inhalt

}

Dankeschön

typedef vector<int> myVec;

myVec GetVector()
{
 myVec vec;
 vec.push_back(10);
 vec.push_back(20);
 return vec;
}

int main(int argc, char* argv[])
{
 myVec vect = GetVector();
 cout<<vect[0]<<endl;
 cout<<vect[1];

        return 0;
}

Am besten by reference als Parameter übergeben oder per Smartpointer zurück geben:

void fillVector(std::vector<int> &vec) // auf das &-Zeichen achten!
{
   vec.push_back(1);
   vec.push_back(2);
   vec.push_back(3);
}

std::auto_ptr<std::vector<int> > createVector() {
     std::auto_ptr<std::vector<int> > vec(new std::vector<int>());
     return vec;
}

typedef ist nur eine Erleichterung, um den Code 1. übersichtlich und 2. wartbarer zu halten. Aber das eigentliche Problem löst es nicht.

Was hat denn typedef mit seiner Frage zu tun?
Und dann auch noch als Return by Value? Da freut sich der User, wenn ein Vector mit ein paar Mio. Elementen zurück gegeben wird.

er wollte einen vector zurückgegeben haben, das habe ich ihm erklärt!
das ein by reference wohl besser ist, ist klar!

Artchi schrieb:

typedef ist nur eine Erleichterung, um den Code 1. übersichtlich und 2. wartbarer zu halten. Aber das eigentliche Problem löst es nicht.

und wie sieht es bei der rückgabe von funktionszeiger aus?

template<typename T>
class foo_mover
{
private:
    struct foo_mover_ref
    {
        foo_mover_ref(T& t) : p_( &t ) {}
        T* p_;
    };
public:
    foo_mover(const T& src) : v_() { swap( v_, const_cast< T& >( src ) ); }
    foo_mover(foo_mover& other) : v_() { swap_( v_, other.v_ ); }
    foo_mover(foo_mover_ref ref) : v_() { swap( v_, *ref.p_ ); }
    foo_mover& operator=(foo_mover& other)
    {
        swap( v_, other.v_ );
        return *this;
    }
    foo_mover& operator=(foo_mover_ref ref)
    {
        swap( v_, *ref.p_ ); }
        return *this;
    }
    T& movee() { return v_; }
    operator foo_mover_ref() { return foo_mover_ref( v_ ); }
private:
    T v_;
};

using namespace std;
vector_mover< vector< int > > foo()
{
    vector<int> v;
    v.push_back( 1 );
    v.push_back( 2 );
    return v;
}

int main()
{
    vector< int > v;
    v.swap( foo().movee() );
}

die destruktive copy-semantik des auto_ptr wird damit (nahezu) universell möglich ohne die doppelte indirektion des auto_ptrs zu benötigen. der const_cast ist leider notwendig (wir möchten ja vielleicht den vector direkt im return-statement erzeugen) und gefährlich - da müssen wir auf rvalue-referenzen warten (und dann wird das ganze möglicherweise sowieso überflüssig, falls sich das kommittee entschliesst, die container mit move-konstruktoren zu ergänzen). das swap (dort wo die funktion aufgerufen wird) ist leider immer noch umständlich (bei selbsterstellten klassen kann man nat. entsprechende konstruktoren, assignment-operatoren bereitstellen, so das der ganze vorgang transparent ist)- und langsamer als der fall, wenn andernfalls copy-elision angewandt wird - dafür funktioniert es immer.