Segmentation fault

Braunstein

Um es ein wenig genauer zu machen. Du kannst beim dynamischen Erzeugen von Klasseninstanzen kein malloc verwenden, da hierbei keine Konstruktoren aufgerufen werden. Nimm new und es sollte gehen.

Lagrange

vielen Dank Jungs!! Hab es schon hinbekommen. Nur falls nocheinmal jemand anderes das gleiche Problem hat - sozusagen fuer die Statistik :):

Matrix<int>* ve = new Matrix<int>[index];

-CLOSE-

Braunstein

Ich hoffe du hast dann auch das richtige delete genommen.

THX 1138

Um es ein wenig genauer zu machen.. :p

delete[]

Lagrange

Ok, jetzt bin ich dummerweise wieder in einer Sackgasse. Problem ist noch wie oben. Ich will ein Array von Matritzen erzeugen. Mit

Matrix<int>* Store = new Matrix<int>[index];

hat das wunderbar geklappt - zumindest solange ich die Groesse des Vektors kenne. Leider muss ich diesen jetzt erweitern/verlaengern.

Wenn ich normal Matrizen habe, funktioniert das wunderbar mit Store.resize(x,y). Leider sollte das hier nicht klappen. Hat einer eine Idee? Schon mal vielen Dank fuer die erneute Hilfe

Simon2

Lagrange schrieb:

Ok, jetzt bin ich dummerweise wieder in einer Sackgasse. Problem ist noch wie oben. Ich will ein Array von Matritzen erzeugen. Mit

Matrix<int>* Store = new Matrix<int>[index];

hat das wunderbar geklappt - zumindest solange ich die Groesse des Vektors kenne. Leider muss ich diesen jetzt erweitern/verlaengern....

Dann mach es nicht selbst, sondern nimm die Standardmittel dafür: std::vector

Dann sieht das so aus:

std::vector<Matrix<int> > Store(index);
// Achtung: Leerzeichen bei "> >" ist wichitg

Einzelne Elemente hinzufügen kannst Du mit push_back()...
Und deleten brauchst Du auch nichts mehr.

Alternativ kannst Du natürlich das Rad neu erfinden und Dich mit einer Menge Segfaults rumschlagen

Gruß,

Simon2.

Gast++

Hallo!

Ups, da liegt glaub ich einiges im Argen:

Du musst die Zeigerreferenz übergeben da ansonsten malloc() oder new() an eine temporäre Kopie zuweisen würden - nämlich an ein long das auf dem Stack liegt und den alten Wert des (NULL ?) - Zeigers enthält.
[index] meint doch eher [size], oder?
Ist Matrix eigentlich eine class oder ein struct?
Was build() macht scheint mir in einen benuzerdefinierten Matrix-Konstruktor zu passen.
Wieso wählst Du diese Strategie zur Einrückung?
Stroustrups Konvention sieht völlig anders aus und ist imo viel besser zu lesen.

Solch kmplizierte Zeigerarithmetik muss optisch gut dargestellt werden.

Probleme bei 250*250 sind wohl eher Probleme bei 256*256 was 2^16 = 65536 enspricht. Also irgendwas bei 64k. Bei der Hausnummer gab's schon oft Probleme.

=> Wie ist Matrix intern aufgebaut ? <=
- vector< vector<T> >
- T[][]

Vorsicht!

T[][] ist KEIN T** ! Stroustrup C++PL §C.7.3 - da geht's um Matrizen

Teilchen als 1/0 ist ja (noch) boolean, bleibt das so?
Wenn ja : Du bildest es auf ein int ab. Hast Du Dich mal mit <bitset> befasst ? Es könnte eine effiziente Implemntierung damit geben.

Grüsse

*this

Lagrange

Vielen Dank!

Ich haette nicht gedacht, dass es so einfach ist - warum komme ich auf sowas nie selbst :). Simons2s Vorschlag funkioniert einwandfrei

Auch vielen Dank an Gast++ - leider bin ich fuer deine Antwort noch zu dumm, werde sie aber auf jeden Fall nochmal in Ruhe durchlesen und versuchen zu verstehen. Ein Glueck tut es wie gesagt schon der Ansatz von Simon

Braunstein

@Gast++
zu 1.
Bei der einfachen Ereugung mit new braucht man keine Zeigerreferenz. Das brauchst du dann eher wenn du dieses in eine Funktion asulagerst. malloc hat hier eh nichts zu suchen da dort keine Konstruktoren aufgerufen werden. Es sei denn du bastelst dir hier was mit einem placement new zusammen was hier aber gar nicht nötig ist.
zu 3.
Wasc machst das für einen Unterschied ob es eine class oder eine struct ist? Die werden beide gleich behandelt.

Gast++

Braunstein schrieb:

@Gast++
zu 1.
Bei der einfachen Ereugung mit new braucht man keine Zeigerreferenz. Das brauchst du dann eher wenn du dieses in eine Funktion asulagerst.

Ja, und der Zeiger um den es geht ist ein formaler Parameter der build Funktion.
Lies bitte mal die Zeilenendkommentare im OP.

Braunstein schrieb:

malloc hat hier eh nichts zu suchen da

Das war bereits erklärt worden; hier gings um die Übergabe der Zeigerreferenz.

Braunstein schrieb:

dort keine Konstruktoren aufgerufen werden. Es sei denn du bastelst dir hier was mit einem placement new zusammen was hier aber gar nicht nötig ist.
zu 3.
Wasc machst das für einen Unterschied ob es eine class oder eine struct ist? Die werden beide gleich behandelt.

Dann zeig mir doch bitte mal einen "struct-Konstruktor" mit ctor Semantik.

Grüsse

Gast++

CStoll

Gast++ schrieb:

Braunstein schrieb:

dort keine Konstruktoren aufgerufen werden. Es sei denn du bastelst dir hier was mit einem placement new zusammen was hier aber gar nicht nötig ist.
zu 3.
Wasc machst das für einen Unterschied ob es eine class oder eine struct ist? Die werden beide gleich behandelt.

Dann zeig mir doch bitte mal einen "struct-Konstruktor" mit ctor Semantik.

Grüsse

Gast++

Aus C++ Sicht gibt es nur einen Unterschied zwischen 'struct' und 'class' - struct-Elemente sind per Default public, class-Elemente private. Ansonsten sind beide völlig identisch.
(insbesondere kann ein struct auch Memberfunktionen, private Member (mußt du explizit angeben) und sogar Ctor'en haben)

Gast++

CStoll schrieb:

Aus C++ Sicht gibt es nur einen Unterschied zwischen 'struct' und 'class' - struct-Elemente sind per Default public, class-Elemente private. Ansonsten sind beide völlig identisch.
(insbesondere kann ein struct auch Memberfunktionen, private Member (mußt du explizit angeben) und sogar Ctor'en haben)

Danke für den Hinweis!

Das ändert aber nichts daran dass die freie "build"-Funktion Aufgaben wahrnimmt die gut in einen Konstruktor passen würden.
Auch in einen struct-Konstruktor.

Grüsse

Gast++

Lagrange

Ich stoere ja nur ungerne euere Fachsimpelei - von der ich btw kein Wort verstanden habe - aber bezog sich ja auch ein Glueck nicht mehr richtig auf mein Problem.

Auf jeden Fall klappt die ganze Sache doch noch nicht so wirklich. Ich habe das gestern mal schnell mit einem kleinen Testprogramm getestet. Einwandfrei funktioniert:

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include"bamatrix.h"

int main()
{

int index = 0;
Matrix<int> M(2,2);
std::vector<Matrix<int> > Store(index); 

   for(int i = 0; i<4; i++)
   {
   M[0][0] = i;
   M[0][1] = i;
   M[1][0] = i;
   M[1][1] = i;
   Store.push_back(M);
   }

Matrix<int> K(2,2);
K = Store[3];

cout << K[1][1] << endl;
}

Aber sobald ich es in ein groesseres Programm einbaue, bekomme ich beim ausfuehren von

std::vector<Matrix<int> > Store(index);

flogende Fehlermeldung (mit der man natuerlich wieder unglaublich viel anfangen kann): *** glibc detected *** malloc(): memory corruption (fast): 0x097d7fa8 ***

CStoll

Der vector-Ctor sollte eigentlich keine Probleme haben. Aber womöglich hast du den Heap schon vor diesem Aufruf zerlegt. Wie sieht denn der Ctor der Klasse Matrix<> aus?

(btw, den Parameter 'index' kannst du auch weglassen -der Default-Ctor legt bereits einen vector mit 0 Elementen an)

PS: Da fehlt übrigens ein '#include <vector>' - und statt der C-Header solltest du ihr C++ Äquivalent (<cxxx> anstelle von <xxx.h>) verwenden.

Lagrange

Ersteinmal danke fuer die schnelle Antwort - ich weiss aber leider nicht was ein Ctor ist - sorry

Paddy82

Ctor steht für Constructor und Dtor für Destructor,

Gruß Paddy

Lagrange

Ok ich bin nicht 100%ig sicher, aber ich wuerde sagen die ersten 2 Zeilen sind der Ctor - zur sicherheit habe ich mal den kompletten public-Bereich kopiert

Matrix();
    Matrix( int rows, int cols );  // size rows x cols
    Matrix ( const Matrix & mat);  // copy constructor
    ~Matrix();

    // Assignment
    const Matrix& operator = (const Matrix & Rmat);

    // Accessors
    int numrows( ) const;  // number of rows
    int numcols( ) const;  // number of columns
    const vector<ItemType>& operator[] (int index) const;

    // Modifiers
    vector<ItemType>& operator[] (int index);
    void resize( int newRows, int newCols ); // resizes matrix to
                                             // newRows x newCols

Sieht aber wirklich fast so aus, dass ich davor irgendwas falsch gemacht habe - weil wenn ich die Deklaration einfach an den Anfang des Programms setze hat er keine Probleme mehr damit. Naja ich mache jetzt einfach mal so weiter und hoffe dass es so klappt

Vielen Dank ihr zwei

CStoll

Ja, die ersten drei Zeilen sind die Construktoren deiner Matrix-Klasse. Aber für die Fehlersuche dürfte es hilfreicher sein zu wissen, was sie eigentlich machen (in deinem Programm besonders der zweite -"Matrix(int rows,int cols);").

PS: Sorry für die Verwirrung - das ist die Macht der Gewohnheit

Paddy82

Die ersten drei Zeilen sind definitionen von Konstruktoren (Ctor's) und die vierte zeile ist der dtor

Lagrange

Naja

Matrix<int> M(x,y)

definiert eine Matrix M in meinem Programm mit x Zeilen und y Spalten

P.S. sorry dass ich mich so dumm anstelle - vielleicht haette ich waehrend meinem Studium doch den Java-Kurs machen sollen, dann braeuchte ich nicht von vorne anfangen