Übergabe von Vektor an Funktion mit Zeiger



  • Hallo,

    habe folgendes Problem: Möchte einen Vektor an eine Funktion übergeben (call by reference) und dort mit "Zufallswerten" füllen und diese testweise ausgeben lassen.
    Dabei bricht der Compiler bei 34 mit dieser Meldung ab:

    "Binärer Operator '=': Es konnte kein Operator gefunden werden, der einen
    rechtsseitigen Operanden vom Typ 'int' akzeptiert"

    #include "stdafx.h"
    #include <iostream>
    #include <vector>
    #include "time.h"
    #include "stdio.h"
    
    using namespace std; 
    
    void CreateData(short in, vector<short>* arr);
    
    int main(int argc, _TCHAR* argv[])
    {	
            short n=5;
    	vector<short> mtrx[n];
    
    	CreateData(n, mtrx);	
    
    	return 0;
    }
    
    void CreateData (short in, vector<short>* arr)
    {
    	time_t t;
    
    	time(&t);
        srand((unsigned int)t);           
    
    	for (int i=0; i<in; i++)
    	{
    		arr[i]=rand();
    		cout << arr[i] << endl;
    	}
    }
    

    Benutze nen Vektor anstatt ein eindimensionales Array, weil ich die Größe später dynamisch vorgeben will.
    Für Verbesserungsvorschläge bin ich (als Anfänger) auch offen. Versteh nicht wirklich, warum er den Vektor so in der Funktion nicht nimmt, der Programmteil funktioniert problemlos in der main?



  • überleg dir mal, was du in Zeile 32 wem zuweisen willst

    greetz KN4CK3R



  • Willst du nicht eher das:

    #include <iostream>                                                              
    #include <cstdlib>                                                               
    #include <vector>                                                                
    
    using namespace std;                                                             
    
    void CreateData(short in, vector<short> &arr);                                   
    
    int main(int argc, char **argv)                                                  
    {                                                                                
            short n=5;                                                               
        vector<short> mtrx(n);                                                       
    
        CreateData(n, mtrx);                                                         
    
        return 0;                                                                    
    }                                                                                
    
    void CreateData (short in, vector<short> &arr)                                   
    {                                                                                
        time_t t;                                                                    
    
        time(&t);                                                                    
        srand((unsigned int)t);                                                      
    
        for (int i=0; i<in; i++)                                                     
        {                                                                            
            arr[i]=rand();                                                           
            cout << arr[i] << endl;                                                  
        }                                                                            
    }
    

    Das habe ich geändert:

    1. Vektor der Länge n anlegen (runde Klammern statt eckige)
    vector<short> mtrx(n);
    
    1. Call by reference (und nicht via Zeiger. Wobei das natürlich auch gehen würde. Dann muss man der Funktion aber auch einen Zeiger übergeben)
    void CreateData (short in, vector<short> &arr)
    


  • Oh man,
    da hab ichs echt etwas verpeilt...

    Danke für die schnelle Hilfe, funktioniert jetzt!



  • time_t t;                                                                     
    
        time(&t);                                                                     
        srand((unsigned int)t);                                                       
    
        for (int i=0; i<in; i++)                                                     
        {                                                                             
            arr[i]=rand();
    

    Das will er sowieso nicht.



  • Eigentlich löst man soetwas mit Iteratoren. Das ist eine Art Pointer auf ein Element eines Containers, nur in sicher und speicherselbstverwaltend.

    Durch das Verwenden von Iteratoren, musst du auch nicht die Länge des Vektors als Argument an die Funktion CreateData übergeben.

    void CreateData (vector<short> &arr)
    {
        time_t t;
    
        time(&t);
        srand((unsigned int)t);          
    
        for (vector<short>::iterator it=arr.begin();it!=arr.end();it++)
        {
            *it = rand();
            cout << *it << endl;
        }
    }
    

    Iteratoren



  • Telefonmann schrieb:

    Durch das Verwenden von Iteratoren, musst du auch nicht die Länge des Vektors als Argument an die Funktion CreateData übergeben.

    bei einem std::vector muss man eh keine größe mit angeben. Dafür hat std::vector die methode size().



  • firefly schrieb:

    Telefonmann schrieb:

    Durch das Verwenden von Iteratoren, musst du auch nicht die Länge des Vektors als Argument an die Funktion CreateData übergeben.

    bei einem std::vector muss man eh keine größe mit angeben. Dafür hat std::vector die methode size().

    ...
    Dir ist klar, dass du die Größe implizit (durch den entsprechenden Member) mitgibst? Bei Iteratoren brauchst du überhaupt keine Größe (völlig größenunabhängig), das ist ja der Punkt.



  • Ich sehe hier keinen Grund einen Zeiger/eine Referenz auf std::vector zu übergeben.
    Wieso nicht einfach Zeiger + Anzahl?

    void CreateData(size_t count, short* p) // unüblich in der reihenfolge - üblich wäre eher (p, count)
    {
        srand(time(0));
    
        for (size_t i = 0; i < count; i++)
        {
            p[i] = rand();
            cout << p[i] << endl;
        }
    }
    
    int main()
    {
        size_t n = 5;
        std::vector<short> m(n);
    
        CreateData(n, &m[0]);
    }
    

  • Mod

    hustbaer schrieb:

    Wieso nicht einfach Zeiger + Anzahl?

    template <typename OutputIterator> void CreateData(OutputIterator out, std::size_t how_many)
    

    ? Oder

    template <typename Iterator> void CreateData(Iterator begin, Iterator end)
    

    ?



  • @SeppJ:
    Ja, so kann man es auch machen.
    Es gibt Fälle wo es besser ist ein Template zu verwenden, und welche wo eine einfache Funktion besser ist.

    Es muss nicht immer überall alles ein Template sein.



  • hustbaer schrieb:

    Ich sehe hier keinen Grund einen Zeiger/eine Referenz auf std::vector zu übergeben.
    Wieso nicht einfach Zeiger + Anzahl?

    void CreateData(size_t count, short* p)
    

    Wenn ich den Code richtig verstehe, wird der Zeiger anderweitig nicht mehr
    benötigt,ebenso die Variable count, also dürfte nichts dagegen sprechen, beide konstant zu machen, oder?
    Also

    void CreateData(const size_t count, short*const p)
    


  • redrew99 schrieb:

    hustbaer schrieb:

    Ich sehe hier keinen Grund einen Zeiger/eine Referenz auf std::vector zu übergeben.
    Wieso nicht einfach Zeiger + Anzahl?

    void CreateData(size_t count, short* p)
    

    Wenn ich den Code richtig verstehe, wird der Zeiger anderweitig nicht mehr
    benötigt,ebenso die Variable count, also dürfte nichts dagegen sprechen, beide konstant zu machen, oder?
    Also

    void CreateData(const size_t count, short*const p)
    

    const in pass-by-value is indeed redundant. The function can't make changes to the original variable anyway, because it has a local copy thereof. Now one can argue that even in that case, the use of const documents the fact that the function doesn't change its local copy. However, do we really care about this? If you are the implementer of the function, you probably do but you certainly don't need to document this fact, as it is merely an implementation detail, not a part of the interface. Users of this function certainly don't care; all they need to know is that the original variable can't be altered, and the use of pass-by-value, with or without const, already guarantees that. To conclude, the use of const in pass-by-value is an example of over-specification that exposes an implementation detail. In general, exposing implementation details is bad object-oriented programming practice.

    http://www.c-plusplus.net/forum/294092-full



  • thx^^


Anmelden zum Antworten