Vector Problem

cofriga

so also ich habe mal versucht einen zweidimensionalen vector zu erstellen, der jetzt zu versuchszwecken in jeder zeile die arraywerte von part übernimmt:

[cpp]
        m=7;
        Part = new int[m];   
        for (i=0; i<m; i++)                                 
            Part[i]=1;

	vector<int> v;
	vector<vector<int> >g;

        for(i=0; i<m; i++)
            for(j=0; j<m; j++)
                {   

                        g[i][j]=Part[j];

                }
[/cpp]

das programm stürtzt ab.
ist da ein fehler in der umsetzung oder bin ich da komplett auf dem falschen weg.
denn ein tutorial sagt mal so, das andere mal so. sicherlich widersprechen sie sich nicht, aber ich weiß nicht, was ich in meinem fall anwenden muss.

ich habe es auch mit v.push_back () versucht, aber ich weiß nicht, wie ich das zweidimensional machen soll.

und noch eine zweite frage:

ich habe eine funktion fkt(*par, m) die den array part bisher bearbeitet hat.
kann ich - ohne die funktion wesentlich zu verändern- auch eine "zeile" des vektors mit der funktion verändern lassen? Denn sonst ist das alles hinfällig.

danke im voraus

drakon

Also erstens haben die Variablen i und j keinen Typ, aber ich denke, dass du die wo anderst deklariert hast.

Zweitens haben diese vectoren eine grösse von 0. Das heisst, wenn du einen Wert einfügen willst, musst du das entweder mittels push_back (für beide vectoren) machen oder den resize und eine neue grösse angeben.

(ungetestet)

vector<int> v;
    vector<vector<int> >g;

       v.resize (m);
       g.resize (m);

        for(i=0; i<m; i++)
            for(j=0; j<m; j++)
                {  

                        g[i][j]=Part[j];

                }

Braunstein

Wozu dient hier v?
Wenn di Größe feststeht kann man das gleich im Konstruktor des vector angeben.

vector<vector<int> > g(m, vector<int>(m));

Das erzeugt einen 2D-vector der Größe m*m
Dann kan man direkt reinschreiben.

drakon

Braunstein schrieb:

Wozu dient hier v?
Wenn di Größe feststeht kann man das gleich im Konstruktor des vector angeben.
vector<vector<int> > g(m, vector<int>(m));
Das erzeugt einen 2D-vector der Größe m*m
Dann kan man direkt reinschreiben.

Genau, aber er (jetzt hätte ich schon fast sie gesagt.. ) hat gesagt, dass sich das bei jedem durchlauf ändern kann. Darum würde sich das resize mehr anbieten.

Braunstein

Auch hier kann man den Konstruktor und swap bemühen.

vector<vector<int> > g;
// dann irgendwann
vector<vector<int> >(m, vector<int>(m)).swap(g);

Dein einfaches resize(m) hat ja auch nur den äußeren vector geändert. Den Inneren müsstest du auch noch anpassen. Das Problem hast du mit swap nicht. Außerdem ist es so ein Einzeiler.

drakon

Braunstein schrieb:

Dein einfaches resize(m) hat ja auch nur den äußeren vector geändert. Den Inneren müsstest du auch noch anpassen. Das Problem hast du mit swap nicht. Außerdem ist es so ein Einzeiler.

Stimmt natürlich. Aus irgendeinem Grund habe ich nur das v gesehen und wollte das resizen.. (Warum ist das überhaupt dort )

cofriga

Braunstein schrieb:

Auch hier kann man den Konstruktor und swap bemühen.
vector<vector<int> > g;
// dann irgendwann
vector<vector<int> >(m, vector<int>(m)).swap(g);
Dein einfaches resize(m) hat ja auch nur den äußeren vector geändert. Den Inneren müsstest du auch noch anpassen. Das Problem hast du mit swap nicht. Außerdem ist es so ein Einzeiler.

vielen vielen dank.
aber die beiden vektoren sind sowieso unterschiedlich lang.

und sehe ich das richtig, dass ich auch mit vektoren nur quadratische "matrizen" machen kann?

cofriga

Braunstein schrieb:

Auch hier kann man den Konstruktor und swap bemühen.
vector<vector<int> > g;
// dann irgendwann
vector<vector<int> >(m, vector<int>(m)).swap(g);
Dein einfaches resize(m) hat ja auch nur den äußeren vector geändert. Den Inneren müsstest du auch noch anpassen. Das Problem hast du mit swap nicht. Außerdem ist es so ein Einzeiler.

vielen vielen dank.
aber die beiden vektoren sind sowieso unterschiedlich lang.

und sehe ich das richtig, dass ich auch mit vektoren nur "matrizen" machen kann?

denn wie gesagt, ich brauche eher
m verschiedene zeilen, wobei m von durchgang zu durchgang sich ändert und
die m verschiedenen zeilen sind fast alle unterschiedlich lang auch in einem durchgang...

queer_boy

cofriga schrieb:

und sehe ich das richtig, dass ich auch mit vektoren nur quadratische "matrizen" machen kann?

nein. du kannst auch x*y matrizen damit machen. oder besser gesagt: jeder vektor hat eine beliebige (von dir festlegbare) länge. allerdings hat jeder vektor (idR) eine größe (kapazität), die die länge übersteigt und nicht genau festlegbar ist. daher kannst du nicht davon ausgehen, dass &matrix[0][0] funktioniert.
in diesem fall ist es eine überlegung wert, anstatt vektoren ineinander zu schachteln, eine zweidimensionale matrix auf einen (eindimensionalen) vektor abzubilden.

/edit: erweitert nach cofrigas zweitem post.

cofriga

vielen dank für die antwort, ich habe es nochmal überlegt und werde es anders angehen.
ich werde den array nach den berechnungen in einen string umwandeln und ablegen.

dann brauche ich bei m array stellen einen zweidimensionalen vektor mit größe m*unbekannt.
dann dürfte es - diesmal auch praktisch - klappen.

thx

OhneName

Ich glaube du hast immernoch ein Verständnisproblem mit "zwei-dimensionalen" Vektoren. Erstmal der ein-dimensionale Vektor und wie man Elemente hinzufügt und darauf zugreift:

vector<int> v;
v.push_back(3); // Elemente einfügen
v.push_back(14);
v[0] = 4; // auf Elemente zugreifen
v[1] = 13;

Wenn ein Element noch nicht existiert, im Beispiel v[2], weil nur 2 Elemente hinzugefügt wurden, dann kannst du natürlich auch nicht mit dem Indexoperator darauf zugreifen.

Und nun der Vektor, der als Typ einen weiteren Vektor enthält. Hier muss man darauf achten, dass man dadurch auch erstmal gezwungen ist weitere Vektoren einzufügen:

vector<vector<int> > v;
v.push_back(vector<int>()); // Elemente einfügen
v.push_back(vector<int>());
v[0].push_back(3);
v[0].push_back(14);
v[1].push_back(7);
v[1].push_back(19);
v[0][0] = 4; // auf Elemente zugreifen
v[0][1] = 13;
v[1][0] = 8;
v[1][1] = 19;

Wie du siehst musst du hier erstmal den "äußeren" Vektor füllen und anschließend die "inneren". Auf diese Weise kannst du also auch zweidimensionale Felder mit unterschiedlichen Zeilenlängen machen. Das hinzufügen von Elementen mittels push_back kannst du dir sparen, wenn du einen passenden Konstruktor verwendest, der bereits n Elemente anlegt, auf die du dann anschließend auch zugreifen kannst.

cofriga

danke für die erklärung
genauso habe ich es auch vorher gemeint, aber wie ich damit umgehe, habe ich noch größte schwierigkeiten

aber mit v.push_back() kann ich ja auch strings einfügen und das wäre dann genau das was ich brauche, wenn er bei der ausgabe mit

[cpp] for( int i=0; i < v.size(); i++ )             
                for( int j=0; j < v.size(); j++)
                {  
                cout << v[i][j];
[/cpp]

bei der letzten belegten stelle auch automatisch aufhört (wovon ich ausgehe)
sonst kann man das auch mit einem counter regeln.

zudem muss ich nie auf einzelne elemente des "inneren" vektors zugreifen, sondern brauche nur mehrmals den ganzen vektor, falls das noch eine bedeutung hat.

drakon

Du willst ja die innere Schleife durchlaufen, oder?
Also müsste das eher so heissen:

for( int i=0; i < v.size(); i++ )            
                for( int j=0; j < v[i].size(); j++)
                {  
                cout << v[i][j];

Sonst gibt es einen Fehler, wenn die beiden vektoren mal nicht gleichgross sind..