Member bei Aufruf deklarieren



  • Ok, ich glaube, ich kriege das mit endlichem Aufwand irgendwann hin. Eines macht mir alles Schwierigkeiten, da ich auch den Sinn nicht ganz verstehe:

    Ursprünglich:

    int lx[N];
    
    memset(lx, 0, sizeof(lx));
    

    Ich versuche da jetzt etwas á la

    vector<int> lx;
    
    memset(lx, 0, lx.size());
    

    draus zu machen. Klappt allerdings nicht 🙂

    error: cannot convert ‘std::vector<int>’ to ‘void*’ for argument ‘1’ to ‘void* memset(void*, int, size_t)’
    memset(lx, 0, lx.size());

    Zunächst: memset sorgt (in dem Fall) dafür, dass alle Einträge von lx 0 gesetzt werden ? Richtig ?
    Dann: Ich verstehe nicht, warum es vorher funktionierte aber jetzt nicht.. also ich kann die Fehlermeldung nicht übertragen 😞



  • stell dir std::vector vor wie ein array, welches eine beliebige Anzahl Elemente enthalten kann. Mit std::vector::push_back kannst du Elemente hinten anfügen, der vector wächst automatisch mit. D.h.

    vector<int> v;  // leerer vector, v.size() == 0
    v.push_back(42);  // 1 Element, v.size() == 1;
    

    Da std::vector die Anzahl der Elemente kennt, kannst du einfach iterieren:

    for (std::size_t i = 0; i < v.size(); ++i)
        std::cout << v[i] << ' ';
    

    Oder, wenn du einfach den kompletten vector durchlaufen willst, range-based-for:

    for (int i : v)
        std::cout << i << ' ';
    

    Mit memset brauchst du da überhaupt nicht kommen. Auch nicht für C-Style Arrays oder structs:

    int arr[10]{};  // Alle Elemente haben den Wert 0
    

    D.h. du ließt einfach aus der Datei und für jeden Eintrag machst du ein push_back . Du kannst beliebig viele Einträge lesen, da vector intern automatisch seinen Speicher verwaltet.



  • Danke für die ausführliche Antwort! War mir im Prinzip sogar bewusst, habe es bislang nur anders (umständlicher) gemacht, daher nice to know 🙂

    Ich hätte wieder etwas:

    Ursprünglich:

    static const int N=10;
    int x, y;
    int slack[N];
    int lx[N], int ly[N];
    int cost[N][N];
    
    for(int y = 0; y < n; y++)
    if((lx[x] + ly[y] - cost[x][y]) < slack[y])
    

    Habe ich zu:

    static const int N=10;
    int x, y;
    vector<int> lx[N], ly[N];
    vector<int> slack[N];
    valarray<int> cost(N,N);
    
    for(int y = 0; y < n; y++)
    if((lx[x] + ly[y] - cost(x,y)) < slack[y])
    

    gemacht. Bekomme dafür jedoch:

    error: no match for call to ‘(std::valarray<int>) (int&, int&)’

    Warum ? Muss man anders auf Elemente von valarray zugreifen ?

    PS: Ist es

    cost[(x,y)])

    ?



  • Vektoren initialisierst du nicht mit [], sondern mit ()
    Also

    vector<int> lx(N), ly(N);
    

    Oder wenn du direkt 0 drin stehen haben willst:

    vector<int> lx(N,0);
    vector<int> ly(N,0);
    

    Valarray ist kein Mehrdimensionales Array, sondern ein normales Array auf dem bestimmte mathematische Operationen definiert sind.

    Außerdem deklarierst du "y" doppelt.

    Edit:
    Anstelle von deinem Valarray suchst du vlt nach sowas:

    std::vector<std::vector<int> > cost;
    


  • Danke!

    Für

    #include <vector>
    const int N;
    vector<vector<int> > cost (N,N);
    using namespace std;
    

    erhalte ich

    error: no matching function for call to ‘std::vector<std::vector<int> >::vector(const int&, const int&)’
    vector<vector<int> > cost (N,N);

    PS: Brauche ich

    vector<vector<int> > cost(N);

    ?
    Ist das dann eine quadratische Matrix ? Die brauche ich zwar aber wie wäre es denn bei nicht-quadratischen Matrizzen ?



  • Nein, du erhältst so keine quadratische Matrix, sondern tatsächlich einen Vektor von Vektoren. Wobei die inneren Vektoren unabhängig sind und sogar unterschiedliche Längen haben können.

    Quadratisch wird das zum Beispiel so:

    const int N=10;
    vector<vector<int> > cost (N, vector<int>(N,0));
    

    Dann hast du einen Vektor, gefüllt mit 10 Vektoren die jeweils 10 0en enthalten.



  • Ist es empfehlenswerter z.B. Eigen explizit für Matrizzen zu nehmen oder kann ich prinzipiell einfachen einen Vektor in einen Vektor schreiben ?

    Im Grunde will ich ja nur naiv vorgehen, als hätte ich int array[x][y].

    PS: Ahso, danke übrigens! Ich denke, ich versuche es erstmal mit einem Vektor im Vektor 🙂

    Für

    lx[x] = max(lx[x], cost.max());
    

    erhalte ich nun

    error: invalid types ‘<unresolved overloaded function type>[int]’ for array subscript
      lx[x] = max(lx[x], cost.max());
    

    Ich vermute, max lässt sich bei einem verschachtelten Vektor nicht einfach so anwenden ?



  • Kleiner Tipp: Einfach die Fehlermeldungen aufs wesentliche reduzieren und googeln, so kommt man meistens schneller ans Ziel.



  • Tue ich ja bzw. versuche ich..

    Eigentlich habe ich gerade nicht sonderlich viel mehr als einen Vektor und einen Vektor-Vektor und möchte das max_element von denen haben.

    PS: Ah, ja.. da ist wohl vorher noch was..



  • Ne, max auf ein verschachtelten Vektor schmeißen ist jetzt nicht ganz so einfach. Was soll denn das für ein Maximum sein?? Die Standartbibliothek bietet hier verschiedene Möglichkeiten (e.g. std::max_element pro innerem Vektor, dann musst du nur noch von den Ergebnissen das Maximum finden...), aber einfach das größte Element aus einer "Matrix" gibt es nicht.

    Ob du mit Eigen besser bedient bist kann ich dir nicht sagen, dass kommt auf deine Anwendung an. Wenn du viel mit Matritzen und Vektoren rechnen musst, also wirklich Rechenoperationen ausführen willst, bist du damit wahrscheinlich auf der richtigen Seite.



  • Ok, nochmal danke!

    Ich habe den ersten Part soweit umgewandelt und es scheint probeweise auch zu stimmen 🙂

    const int m_N=3;
    		vector<vector<int> > cost (m_N, vector<int>(m_N,0));
    		vector<int> lx(m_N);
    		vector<int> ly(m_N);
    
    		// initialize labels:
    		for(size_t i = 0; i < lx.size(); ++i)
    		{
    			lx[i]+=0;
    		}
    		for(size_t i = 0; i < ly.size(); ++i)
    		{
    			ly[i]+=0;
    		}
    		for(size_t i = 0; i < cost.size(); ++i)
    		{
    			cost[i][i]=+2;
    		}
    
    		cout << "Size of vectors:" << lx.size() << endl;
    
    		for(size_t i = 0; i < lx.size(); i++)
    		{
    			for(size_t j = 0; j < ly.size(); j++)
    			{
    				lx[i] = max(lx[i], cost[i][j]);	
    				//cout << "ly["<<j<<"]: " << ly[j] << endl; 
    				//cout << "cost["<<i<<"]["<<j<<"] " << cost[i][j] << endl; 				
    			}
    		}
    

    Das soll jetzt gar nicht Korrektur gelesen werden, nur der Vollständigkehit halber und falls sich jemand mit denselben Fragen hierher verirren sollte 🙂
    Ansonsten werde ich den nächsten Part dann mal angehen 🙂
    Mit max scheint es aber jedenfalls zu funktionieren.

    PS: Cool, das Einlesen bzw. Festlegen der Vektoren klappt jetzt auch.
    Wenn ich mit dem Ganzen durch bin, werde ich mal den ganzen Code bereitstellen. So in ein paar Wochen/Monaten.. 😃



  • Oder einfach einen 1D vector als 2D verwenden, man muss halt nur eine Spaltenzahl festlegen und dann ist der Index v[row*width + column]. Macht manches umständlicher, aber das Maximum zu finden wäre einfacher.



  • // initialize labels: 
            for(size_t i = 0; i < lx.size(); ++i) 
            { 
                lx[i]+=0; 
            } 
            for(size_t i = 0; i < ly.size(); ++i) 
            { 
                ly[i]+=0; 
            }
    

    aha?



  • unskilled schrieb:

    // initialize labels: 
            for(size_t i = 0; i < lx.size(); ++i) 
            { 
                lx[i]+=0; 
            } 
            for(size_t i = 0; i < ly.size(); ++i) 
            { 
                ly[i]+=0; 
            }
    

    aha?

    Lässt sich auch geschickt einfacher schreiben:

    Edit: Soll heißen, auf alle Elemente 0 dazu addieren ist vermutlich nicht was du wolltest.



  • // edit: rem: ein edit mal am Anfang. Ist auch was feines.
    // edit: Zusammenfassung:
    // edit: rem: Mann, ich sollte threads vielleicht doch öfter lesen, bevor ich meinen Senf dazugebe.

    Was ist das Ding? Ist das eine echte matrix? oder ein vector<vector>?

    Abbilden:

    std::size_t const columns{ 4 }; // 4 
    std::vector< int > foo( 12 );  // x 3
    
    foo[ y * 4 + x ];  // ... oder anders rum - da gibts Geschmacksrichtungen ...
    

    ... und über Cache-Effizienz kann man dabei auch diskutieren. Kommt auch auf die Daten an.

    Dann das Ganze schön Kapseln und funstuff::matrix_2d_t (oder so) nennen und passt schon.

    Ich hab aber gehört, daß es das irgendwo im internet schon fix-fertig und bugfreetm gibt.

    ~edit 2: teutsch und so~



  • unskilled schrieb:

    // initialize labels: 
            for(size_t i = 0; i < lx.size(); ++i) 
            { 
                lx[i]+=0; 
            } 
            for(size_t i = 0; i < ly.size(); ++i) 
            { 
                ly[i]+=0; 
            }
    

    aha?

    HarteWare schrieb:

    unskilled schrieb:

    // initialize labels: 
            for(size_t i = 0; i < lx.size(); ++i) 
            { 
                lx[i]+=0; 
            } 
            for(size_t i = 0; i < ly.size(); ++i) 
            { 
                ly[i]+=0; 
            }
    

    aha?

    Lässt sich auch geschickt einfacher schreiben:

    Edit: Soll heißen, auf alle Elemente 0 dazu addieren ist vermutlich nicht was du wolltest.

    Richtig 😃
    ohne "+"..

    Swordfish schrieb:

    // edit: rem: ein edit mal am Anfang. Ist auch was feines.
    // edit: Zusammenfassung:
    // edit: rem: Mann, ich sollte threads vielleicht doch öfter lesen, bevor ich meinen Senf dazugebe.

    Was ist das Ding? Ist das eine echte matrix? oder ein vector<vector>?

    Abbilden:

    std::size_t const columns{ 4 }; // 4 
    std::vector< int > foo( 12 );  // x 3
    
    foo[ y * 4 + x ];  // ... oder anders rum - da gibts Geschmacksrichtungen ...
    

    ... und über Cache-Effizienz kann man dabei auch diskutieren. Kommt auch auf die Daten an.

    Dann das Ganze schön Kapseln und funstuff::matrix_2d_t (oder so) nennen und passt schon.

    Ich hab aber gehört, daß es das irgendwo im internet schon fix-fertig und bugfreetm gibt.

    ~edit 2: teutsch und so~

    Den Beitrag verstehe ich nicht 😃
    Ist das rhetorisch, akademisch oder tatsächlich direkt an mich gerichtet ? 🕶

    Was gibt es denn schon fertig/bugfree ?


Anmelden zum Antworten