template <class T> 	void
Matrix<T>::Init_Matrix(Matrix<T> *A)
{
	A->irgendwas = ...
        ....
}

template <class T> 	Matrix<T>* 	
Matrix<T>::New_Matrix()
{
	Matrix<T> *A = new Matrix<T>();
	Init_Matrix(A);

	return A;
}

//in der main z.B:

Matrix<double> *my_matrix;
//Mache was mit my_matrix.

So arbeite ich doch nur mit einem pointer oder?

Ist das unsauber? Sollte ich eher mit Konstruktoren arbeiten?
Wenn ja, warum und wäre es genauso schnell wenn ich statt wie bisher nur einen pointer an methoden übergebe einfach dann das objekt übergebe?
Wie sollte ich es machen?

Danke

Matrix<double> o_matrix;

my_matrix = o_matrix.New_Matrix();

Sauberes C++ ist es wohl nicht oder?

Matrix<T> *A = new Matrix<T>(); // hier
Matrix<double> o_matrix; // und auch hier

und was du da machst ist schon sauber. guck dir z.b. mal das pattern hier an http://de.wikipedia.org/wiki/Fabrikmethode

sich ein objekt auf dem stack zu erzeugen und das objekt dann zu verwenden, um objekte desselben typs auf dem heap anzulegen (pointer) ist allerdings tatsächlich ungewöhnlich ^^

leider stehe ich irgendwie auf dem Schlauch momentan. Ich versuche es so,
aber so wid doch A uninitialisiert verwendet.

template<class T>  Matrix<T>::Matrix(Matrix<T>* A)
{
	A->num_procs = 1;
	A->my_id = 0;
	A->my_nbr_cols = 0;
	A->my_start_index = 0;
	A->n = 0;
	A->all_nbr_cols = NULL;
	A->start_indices = NULL;
	A->my_nnz = 0;
	A->pe = NULL;
	A->symmetric = false;
}

template <class T> 	Matrix<T>* 	
Matrix<T>::New_Matrix()
{
	Matrix<T> *A = new Matrix<T>(A);
// 	Init_Matrix(A);

	return A;
}

Wenn ich es so mache muss ihc ja wieder ein Objekt auf dem stack anlegen um dann ein Objekt auf dem Heap zu alloziieren:

emplate<class T>  Matrix<T>::Matrix()
{
	num_procs = 1;
	my_id = 0;
	my_nbr_cols = 0;
	my_start_index = 0;
	n = 0;
	all_nbr_cols = NULL;
	start_indices = NULL;
	my_nnz = 0;
	pe = NULL;
	symmetric = false;
}

template<class T> Matrix<T>::~Matrix()
{

}

template <class T> 	Matrix<T>* 	
Matrix<T>::New_Matrix()
{
	Matrix<T> *A = new Matrix<T>();
// 	Init_Matrix(A);

	return A;
}

//Aufruf
Matrix<double>* A = New_Matrix() //geht nicht
Matrix<double>* A = o_matrix.New_Matrix() //geht

Könnt ihr mir vielleicht einen Anstoß geben?

Danke

Matrix<double>* A = new Matrix<double>();

(btw, was spricht dagegen, die Matrix auf den Stack zu packen?)

dann hätte ich aber noch eine Frage.
Wenn ich eine Methode aufrufen will die in einer Klasse ist, dazu muss ich dann aber schon immer ein Objekt auf dem stack anlegen oder?

also so:

Matrix<T>::print()
{
      //irgendwas
}

//beim aurufen:
Matrix<double> o_matrix;

o_matrix.print();

Ist das so in Ordnung?

//Objekt auf dem Stack:
Matrix o;
o.print();

//Objekt auf dem Heap:
Matrix* p = new Matrix;
p->print();

Ausnahme sind statische Methoden (in der Klassendefinition als 'static typ func(...);' angegeben), die kannst du auch ohne ein zugehöriges Objekt per "Matrix::create();" aufrufen.

jetzt bekomme ich aber einen haufe an segfaults.
Folgender Code:

Index_Set::Index_Set()
{

}

Index_Set::Index_Set(int len)
{
	idcs = NULL;
	len = len;
	idcs = new int[len];
}

Index_Set::~Index_Set()
{

}

//Index_Set.h
		///Ctor
		Index_Set();
		Index_Set(int len);

		///Dtor
		~Index_Set();

		//Member variables
		///The index set array
    	int 	*idcs; 

		///Lenght of the index set
		int		len;

wird so benutzt:

// Extract pattern from pattern matrix  
	// Create the Index Set J
	J_pattern = o_sub.Get_J_Set(P, col);
	// Copy the values into the big working Index_Set J
	memcpy(J->idcs, J_pattern->idcs, J_pattern->len * sizeof(int));
	J->len = J_pattern->len;

und in Get_J_Set(P,col) folgendes

template <class T> 	Index_Set* 	
Spai_Sub<T>::Get_J_Set(	Pattern	 	*P,
					const int 	col)
{
	Index_Set	*J = NULL;
	J = P->j_sets[col];	
	return J;
}

das pattern wird so gefüllt:
[cpp]
for( int col = 0; col < n; col++)
	{
		i_set = new Index_Set(1);
		i_set->idcs[0] = col;
		P->j_sets[col] = i_set;
	}

[/cpp]

Index_Set 	o_is,
 				*J_pattern = NULL,
 				*J = NULL, 
				*I = NULL;

	// J will be filled with the
	// new J values from pattern
	// and will be updated each augmenting 
	// step.
	J = new Index_Set(A->n);	
       // Extract pattern from pattern matrix  
	// Create the Index Set J
	J_pattern = o_sub.Get_J_Set(P, col);
	// Copy the values into the big working Index_Set J
	memcpy(J->idcs, J_pattern->idcs, J_pattern->len * sizeof(int));
	J->len = J_pattern->len;

und das Pattern hat sowas als Member:

/// All index sets of each column
    	Index_Set 	**j_sets;

		/// The length of the pattern - always size n of
		/// matrix A
		int 		len;

(btw, hast du früher mal mit Java gearbeitet?)

P wird so angelegt:

Pattern::Pattern(int len)
{
	j_sets = NULL;
	len = len;
	j_sets = new Index_Set*[len];	
}

P = new Pattern(n);

PS Nur am Rande: In C++ verwendet man Pointer eher selten - wenn machbar, solltest du deine Variablen auf dem Stack unterbringen. Und die Zugriffe auf Membervariablen sollten lieber von der Klasse selbst übernommen werden.

Der segfault kommt genau beim memcpy() und schreit so:

Conditional jump or move depends on uninitialised value(s)
==7389==    at 0x4022E6C: memcpy (mc_replace_strmem.c:406)
==7389==    by 0x804A1CE: Sp<double>::SP_Column(Matrix<double>*, Matrix<double>*&, Pattern*, int, double, int, int) (in /Source_code/Current/bin/sp)
==7389==    by 0x80497D2: main (in /Source_code/Current/bin/sp)

Hmm....

Vorschlag: Erklär mal, was du überhaupt vorhast. Vielleicht wird der Quelltext dann klarer. (btw, anstelle der nackten Zeiger würde ich lieber mit std::vector<> arbeiten)

Was ich vorhabe ist eigentlich trivial: Ein array in ein anderes kopieren.

Also ich habe 2 Index_Sets und möchte von dem einen Index_Set->idcs array die werte in das andere kopieren Index_Set->idcs.

Das erste wird so initialisiert dass es vom Pattern welches ein array aus Index_Sets hat einfach eine Index_Set extrahiert wird und an J_pattern übergeben wird.
J (also das zweite array wohin kopiert werden soll) wird einfach so initialisiert:

Index_Set* J = new Index_Set(n);

J_pattern wird so gefüllt:

template <class T>     Index_Set*    
Spai_Sub<T>::Get_J_Set(    Pattern         *P,
                    const int     col)
{
    Index_Set    *J = NULL;
    J = P->j_sets[col];   
    return J;
}

Das Pattern füllt seine j_sets so:

Pattern 	*P = new Pattern(n);

	for( int col = 0; col < n; col++)
	{
		i_set = new Index_Set(1);
		i_set->idcs[0] = col;
		P->j_sets[col] = i_set;
	}

wobei der Konstruktor so aussieht:

Pattern::Pattern(int len)
{
	j_sets = NULL;
	len = len;
	j_sets = new Index_Set*[len];	
}

Die Member von Pattern:

/// All index sets of each column
    	Index_Set 	**j_sets;

		/// The length of the pattern - always size n of
		/// matrix A
		int 		len;

das ganze wird so aufgerufen:

Index_Set 	/*o_is,*/
 				*J_pattern = NULL,
 				*J = NULL, 
				*I = NULL;

	J = new Index_Set(A->n);		

	J_pattern = o_sub.Get_J_Set(P, col);

	// Copy the values into the big working Index_Set J
	memcpy(J->idcs, J_pattern->idcs, J_pattern->len * sizeof(int));
	J->len = J_pattern->len;

(und was genau spricht dagegen, vector'en anstelle der dynamischen Arrays zu verwenden?)

das n ist gesetzt. Ich habe es gerade ausgeben lassen.

Ich benutze keine std::vectoren aus einem Grund der vielleicht lächerlich erscheint - aber ich arbeite an einem zeitperformanten programm - und ich hatte mit der std-lib schon einige probleme damals gehabt die mein programm unglaublich langsam werden ließen. Ich hatte es damals umgeschrieben auf reine pointer-arithmetik ohne std-lib und es war viel schneller. Der ein oder andere mag jetzt sagen: Jaja-das lag wohl eher an der umschreibung und nicht an der std-lib. Mag sein - aber nochmal will ich mir das nicht antun. Soviel dazu.

Ja klar, sowas geht ja nicht:

Index_Set::Index_Set(int len)
{
	idcs = NULL;
	len = len;
	idcs = new int[len];
}

sondern nur sowas

Index_Set::Index_Set(int len_a)
{
	idcs = NULL;
	len = len_a;
	idcs = new int[len];
}