Problem mit 2-dimensionalen dynamischen Array

[Baldux66]

Hallo,

ich bin ein Neuankömmling in der C++ Welt. Eigentlich bin ich ja Bauingenieur aber im Zuge meiner Forschungsarbeit muss ich mich jetzt seit Wochen mit C++ beschäftigen. Ich habe auch schon viel gelesen und versucht, aber im Moment stocke ich seit einiger Zeit und deswegen suche ich hier unter Wissenden nach Hilfe. Bitte fresst mich nicht, wenn ich totale Anfängerfehler mache, aber wie gesagt, es ist nicht mein Spezialgebiet.

Im Großen und Ganzen liegt mein Problem bei den zweidimensionalen dynamischen Arrays. Ich weiß, dass es hier die Möglichkeit des Container vector gibt, wollte es aber ohne diesen hinbekommen.

Mein 2-dimensionales dynamisches Array Q wird noch richtig erstellt, aber nach der Zuweisung der Werte über die diversen if-Bedingungen erhalte ich im Debugger folgenden Fehler
CXX0030: Error: expression cannot be evaluated
und diesen bekomme ich leider nicht weg!!
Im weiteren Fall muss die Matrix Q in jedem Schleifendurchgang von while um eine Zeile und eine Spalte erweitert werden und es werden wieder neue Werte ihr zugewiesen.

Ein weiteres Problem liegt dann darin, was ich glaube aber eine Folge des ersten ist, dass wenn ich die Matrix Q im Eingabefenster ausgeben will, es nur innerhalb der while-Schleife am Ende funktioniert. Versuche ich es nach der while-Schleife, an der von mir auskommentierten Stelle, erhalte ich folgenden Fehler:
Unhandled exception at 0x0101337e in test.exe: 0xC0000005: Access violation reading location 0x00000000.

/********** toy.cpp **********/

//#include "localsolver.h"
#include <iostream>

//using namespace localsolver;
using namespace std;

const int n=5;
const int m=12;
const int sat=3;

int main()
{
    //Initialisierung
    int Z = 0;

	int **Q = new int*[n];
    for (int i=0; i < n; i++){
		 Q[i] = new int[n];
	}
	for (int i=0; i < n; i++){
      for (int j=0; j < n; j++){
          Q[i][j] = NULL;
	  }
	}

    int K[m][sat] = {0};
    int Hilfsv_4 = n;
    int P = 10;
	long C[n];

  // Angabe
  int X[m][sat] = { { 1, 2, 3 }, { 1, -2, 3 }, { -1, 2, -3 }, { 2, -3, 4 }, { -2, 3, 4 }, { -2, -3, -4 }, { 2, 4, 5 }, { -2, 3, 5 }, { 2, -3, 5 }, { 3, 4, 5 }, { 3, -4, -5 }, { -3, -4, -5 } };

  // Umwandlung in Penaltyfunktionen
  for (int i=0; i < m; i++){
      if ( X[i][0] > 0 && X[i][1] > 0 && X[i][2] ){
          Z += 1;
          Q[(X[i][0] - 1)][(X[i][0] - 1)] -= 2;
          Q[(X[i][1] - 1)][(X[i][1] - 1)] -= 2;
          Q[(X[i][2] - 1)][(X[i][2] - 1)] -= 2;
          Q[(X[i][0] - 1)][(X[i][1] - 1)] += 1;
          Q[(X[i][1] - 1)][(X[i][0] - 1)] += 1;
          Q[(X[i][0] - 1)][(X[i][2] - 1)] += 1;
          Q[(X[i][2] - 1)][(X[i][0] - 1)] += 1;
          Q[(X[i][1] - 1)][(X[i][2] - 1)] += 1;
          Q[(X[i][2] - 1)][(X[i][1] - 1)] += 1;
          K[i][0] = abs(X[i][0]);
          K[i][1] = abs(X[i][1]);
          K[i][2] = abs(X[i][2]);
      }

      else if ( X[i][0] < 0 && X[i][1] > 0 && X[i][2] > 0 ){
           Q[ (abs(X[i][0]) - 1)][ (abs(X[i][0]) - 1)] += 2;
           Q[ (abs(X[i][0]) - 1)][ (abs(X[i][1]) - 1)] -= 1;
           Q[ (abs(X[i][1]) - 1)][ (abs(X[i][0]) - 1)] -= 1;
           Q[ (abs(X[i][0]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
           Q[ (abs(X[i][2]) - 1)][ (abs(X[i][0]) - 1)] -= 1;
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
      }
      else if ( X[i][0] > 0 && X[i][1] < 0 && X[i][2] > 0 ){
           Q[ (abs(X[i][1]) - 1)][ (abs(X[i][1]) - 1)] += 2;
           Q[ (abs(X[i][0]) - 1)][ (abs(X[i][1]) - 1)] -= 1;
           Q[ (abs(X[i][1]) - 1)][ (abs(X[i][0]) - 1)] -= 1;
           Q[ (abs(X[i][1]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
           Q[ (abs(X[i][2]) - 1)][ (abs(X[i][1]) - 1)] -= 1;
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
      }
      else if ( X[i][0] > 0 && X[i][1] > 0 && X[i][2] < 0 ){
           Q[ (abs(X[i][2]) - 1)][ (abs(X[i][2]) - 1)] += 2;
           Q[ (abs(X[i][0]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
           Q[ (abs(X[i][2]) - 1)][ (abs(X[i][0]) - 1)] -= 1;
           Q[ (abs(X[i][1]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
           Q[ (abs(X[i][2]) - 1)][ (abs(X[i][1]) - 1)] -= 1;
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
      }
      else if ( X[i][0] < 0 && X[i][1] < 0 && X[i][2] > 0 ){
           Q[ (abs(X[i][0]) - 1)][ (abs(X[i][1]) - 1)] += 1;
           Q[ (abs(X[i][1]) - 1)][ (abs(X[i][0]) - 1)] += 1;
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
      }
      else if ( X[i][0] < 0 && X[i][1] > 0 && X[i][2] < 0 ){
           Q[ (abs(X[i][0]) - 1)][ (abs(X[i][2]) - 1)] += 1;
           Q[ (abs(X[i][2]) - 1)][ (abs(X[i][0]) - 1)] += 1;
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
      }
      else if ( X[i][0] > 0 && X[i][1] < 0 && X[i][2] < 0 ){
           Q[ (abs(X[i][1]) - 1)][ (abs(X[i][2]) - 1)] += 1;
           Q[ (abs(X[i][2]) - 1)][ (abs(X[i][1]) - 1)] += 1;
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
      }
      else if ( X[i][0] < 0 && X[i][1] < 0 && X[i][2] < 0 ){
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
      }
  }

  int Hilfsv_5 = 0;
  for (int i = 0; i < m; i++){
      for (int j = 0; j < sat; j++){
		  if ( K[i][j] != 0 ){
          Hilfsv_5 = 1;
		  }
      }
  }

  while (Hilfsv_5 != 0) {

  for (int i=0; i < n; i++){
       C[i] = 0;
  }

  for (int i=0; i < m; i++){
      for (int j=0; j < sat; j++){
		  C[(K[i][j]-1)] += 1;
      }
  }

  int Hilfsv_1 = 0;
  int Hilfsv_2;
  for (int i=0; i < n; i++){
      if ( C[i] > Hilfsv_1 ){
         Hilfsv_1 = C[i];
         Hilfsv_2 = i + 1;
      }
  }

  for (int i=0; i < n; i++){
       C[i] = 0;
  }

  for (int i=0; i < m; i++){
      if ( K[i][0] == Hilfsv_2 ){
         C[(K[i][1]-1)] += 1;
         C[(K[i][2]-1)] += 1;
      }
      else if ( K[i][1] == Hilfsv_2 ){
           C[(K[i][0]-1)] += 1;
           C[(K[i][2]-1)] += 1;
      }
      else if ( K[i][2] == Hilfsv_2 ){
           C[(K[i][0]-1)] += 1;
           C[(K[i][1]-1)] += 1;
      }
  }
  Hilfsv_1 = 0;
  int Hilfsv_3;
  for (int i=0; i < n; i++){
      if ( C[i] > Hilfsv_1 ){
         Hilfsv_1 = C[i];
         Hilfsv_3 = i + 1;
      }
  }

  int **temp = new int*[Hilfsv_4];
  for (int i=0; i < Hilfsv_4; i++){
      temp[i] = new int[Hilfsv_4];
  }

  for (int i=0; i < Hilfsv_4; i++){
       for (int j=0; j < Hilfsv_4; j++){
            temp[i][j] = Q[i][j];
       }
  }

  for (int i=0; i < Hilfsv_4; i++){
        delete[] Q[i];
  }
  delete[] Q;

  int **Q;
  Q = new int*[(Hilfsv_4+1)];
  for (int i=0; i < (Hilfsv_4+1); i++)
      Q[i] = new int[(Hilfsv_4+1)];

  for (int i=0; i < Hilfsv_4; i++){
       for (int j=0; j < Hilfsv_4; j++){
            Q[i][j] = temp[i][j];
       }
  }

  for (int i=0; i < Hilfsv_4; i++){
        delete[] temp[i];
  }
  delete[] temp;

  Hilfsv_4 += 1;

  for (int i=0; i < Hilfsv_4; i++){
	  Q[(Hilfsv_4-1)][i] = 0;
  }
  for (int i=0; i < Hilfsv_4; i++){
	  Q[i][(Hilfsv_4-1)] = 0;
  }

  Q[(Hilfsv_2-1)][(Hilfsv_3-1)] += P;
  Q[(Hilfsv_3-1)][(Hilfsv_2-1)] += P;
  Q[(Hilfsv_2-1)][(Hilfsv_4-1)] -= 2 * P;
  Q[(Hilfsv_4-1)][(Hilfsv_2-1)] -= 2 * P;
  Q[(Hilfsv_3-1)][(Hilfsv_4-1)] -= 2 * P;
  Q[(Hilfsv_4-1)][(Hilfsv_3-1)] -= 2 * P;
  Q[(Hilfsv_4-1)][(Hilfsv_4-1)] += 2 * 3 * P;

  for (int i=0; i < m; i++){
      for (int j=0; j < sat; j++){
          if ( K[i][j] == Hilfsv_2 && K[i][0] == Hilfsv_3 ){
              K[i][0] = 0;
              K[i][1] = 0;
              K[i][2] = 0;
          }
		  else if ( K[i][j] == Hilfsv_2 && K[i][1] == Hilfsv_3 ){
               K[i][0] = 0;
               K[i][1] = 0;
               K[i][2] = 0;
          }
		  else if ( K[i][j] == Hilfsv_2 && K[i][2] == Hilfsv_3 ){
               K[i][0] = 0;
               K[i][1] = 0;
               K[i][2] = 0;
          }
      }
  }

  Hilfsv_5 = 0;
  for (int i=0; i < m; i++){
      for (int j=0; j < sat; j++){
          if ( K[i][j] != 0 ){
          Hilfsv_5 = 1;
		  }
      }
  }
  //Ausgabe der Q-Matrix
  for (int j=0; j < Hilfsv_4; j++){
       for (int k=0;  k < Hilfsv_4; k++) {
           cout << Q[j][k];
        }
        cout << endl;
  }
  }

  //Ausgabe der Q-Matrix
 // for (int j=0; j < Hilfsv_4; j++){
   //    for (int k=0;  k < Hilfsv_4; k++) {
     //      cout << Q[j][k];
       // }
        //cout << endl;
  //}
  cout << Z;

 return 0;
 }

Bitte helft einen verzweifelten Bauingenieur, der zwar weiß, wie man große Brücken baut, aber mit C++ überfordert ist!!

Schon mal ein riesen Danke im voraus!!

[manni66]

Du definierst an zwei Stellen "int **Q", das könnte dein Problem sein (abgesehen von "ich will aber ohne vector auskommen und implementiere es lieber zu Fuß nach).

[Skym0sh0]

du könntest auch wenigstens zum fehler finden vector nutzen (die syntax ist ja fast gleich) und dir dann den genauen fehler herleiten...

[Besorgter Bürger]

Baldux66 schrieb:

Bitte helft einen verzweifelten Bauingenieur, der zwar weiß, wie man große Brücken baut, aber mit C++ überfordert ist!!

Ich hoffe Deine Brücken sind stabiler als Dein Code. Ansonsten teile uns bitte mit wo Deine Bauwerke stehen. Danke!

[camper]

Baldux66 schrieb:

Hallo,

ich bin ein Neuankömmling in der C++ Welt.

Baldux66 schrieb:

Im Großen und Ganzen liegt mein Problem bei den zweidimensionalen dynamischen Arrays. Ich weiß, dass es hier die Möglichkeit des Container vector gibt, wollte es aber ohne diesen hinbekommen.

Das sind zwei Dinge, die erfahrungsgemäß nicht gut zusammenpassen.
Ich wüsste gerne, warum wir uns mit diesen unnötigen Schwierigkeiten auseinandersetzen sollten.

[Ramanujan]

manni66 schrieb:

Du definierst an zwei Stellen "int **Q", das könnte dein Problem sein (abgesehen von "ich will aber ohne vector auskommen und implementiere es lieber zu Fuß nach).

Dazu möchte ich noch anmerken, dass das "int **Q" in der while-schleife steht(Zeile 121 - 257 (rück deinen Quellcode mal vernünftig ein, dann sieht man sowas nämlich viel schneller)). Das Q, auf das du ab Zeile 185 zugreifst, ist nur temporär in einer While-Schleifen-Iteration verfügbar. Da du dein altes Q löscht, ist klar, dass bei der nächsten Iteration ein Segmentation Fault bzw. Access violation kommen muss. Also: Zeile 185 einfach löschen, vielleicht läuft dann dein Programm.

Ich würde übrigens auch an deiner Stelle std::vector benutzen.

[Dudelsack]

1. Benuzte den vector.
2. Das ist kein C++, sondern c mit hier und da c++ Features.
3. Arrays mit new sind enorm fehleranfällig, weil die Arraygrenzen sehr leicht überschritten werden(und nein, "ich achte darauf, dass das nicht passiert" funktioniert nicht)
4. Das abgewandelte Programm ist nicht gut, nur eine Notlösung, sobald du damit weiterarbeitest garnatiere ich dir: mehr Fehler, und nervtötende Bugs.
5. Verwende _ASSERT(Ausdruck) am Anfang überall da wo falsche Eingaben passieren können(vorallem bei Arraygrenzen), dann findest du Fehler sofort.
6. Verwende aussagekräftige Funktionen und Variablen, die main ist sehr unübersichtlich und man weis überhaupt nicht was dort passiert. C, K, Q, X, n, m, sat, Hilfs_v hat null aussagekraft, schreib wenigstens ein Kommentar dran.

Wie dem auch sei, ich habe das daraus gefrickelt. Es läuft durch, knallt aber am Ende nachdem dem main verlassen wird mit einem stack-corruption Fehler. Den musste selber finden.

#include <iostream>

//using namespace localsolver;
using namespace std;

const int n=5;
const int m=12;
const int sat=3;

// Angabe
// Da du X sowieso nie änderst mach es const
const int X[m][sat] = { { 1, 2, 3 }, { 1, -2, 3 }, { -1, 2, -3 }, { 2, -3, 4 }, { -2, 3, 4 }, { -2, -3, -4 }, { 2, 4, 5 }, { -2, 3, 5 }, { 2, -3, 5 }, { 3, 4, 5 }, { 3, -4, -5 }, { -3, -4, -5 } };

//Es muss nicht alles in die main(), in deinem Kommentar sagst du schon "Penaltyfunktionen", dann mach auch Funktionen draus.
// Hab es jetzt so genannt weil du scheinbar immer eine 3x3 Matrix hat die du mit Penalty modifizierst
// 00 01 02
// 10 11 12
// 20 21 22
void PenaltyDiagonal(int** Q, int index, int PenaltyValue) {
	_ASSERT(index<m);//Sowas müsstest du eigentlich überall wo du auf C-Arrays zugreifst haben, sonst knallt es irgendwann und du weist nicht wo, warum und wieso...
	for(int j=0; j<3; j++) Q[X[index][j] - 1][X[index][j] -1] += PenaltyValue;
}

//Evtl. Übersichtlicher
void addPenalty(int** Q, int index, int j, int k, int PenaltyValue) {	
	Q[(X[index][j] - 1)][(X[index][k] - 1)] += PenaltyValue;
}

//Einträge einer Quadratischen Matrix auf 0 Setzen
void zero2DQuadArray (int** Q, int Size) {	
	for (int i=0; i < Size; i++) {
		for (int j=0; j < Size; j++) {
				Q[i][j] = 0;
		}
	}
}

//Einträge einer Quadratischen Matrix in andere Kopieren
void copy2DQuadArray(int** Source, int** Destination, int Size) {
	for (int i=0; i < Size; i++){
		for (int j=0; j < Size; j++){
			Destination[i][j] = Source[i][j];
		}
	}
}

int main() {
	//Initialisierung
	int Z = 0;

	int **Q = new int*[n];
	for (int i=0; i < n; i++) {
		Q[i] = new int[n];
	}

	zero2DQuadArray(Q, n);

	int K[m][sat] = {0};
	int Hilfsv_4 = n;
	int P = 10;
	long C[n];

	// Umwandlung in Penaltyfunktionen
	for (int i=0; i < m; i++) {
		bool FillKwithX=false;	//Diese variable spart dir ne menge Zeilen, weil du in Jedem if K = abs(X) ausführst. Sie kann evtl. sogar komplett weg, da du aber kein else(ohne if) Fall hast weis ich das nicht.
		if ( X[i][0] > 0 && X[i][1] > 0 && X[i][2] ) {
			Z += 1;

			//Versuche redundaten Code in Funktionen zu packen
			PenaltyDiagonal(Q, i, -2);
			//Q[(X[i][0] - 1)][(X[i][0] - 1)] -= 2;
			//Q[(X[i][1] - 1)][(X[i][1] - 1)] -= 2;
			//Q[(X[i][2] - 1)][(X[i][2] - 1)] -= 2;

			//Ist Übersichtlicher so:
			addPenalty(Q, i, 0, 1, 1);
			addPenalty(Q, i, 1, 0, 1);
			addPenalty(Q, i, 0, 2, 1);
			//Q[(X[i][0] - 1)][(X[i][1] - 1)] += 1;
			//Q[(X[i][1] - 1)][(X[i][0] - 1)] += 1;
			//Q[(X[i][0] - 1)][(X[i][2] - 1)] += 1;

			Q[(X[i][2] - 1)][(X[i][0] - 1)] += 1;
			Q[(X[i][1] - 1)][(X[i][2] - 1)] += 1;
			Q[(X[i][2] - 1)][(X[i][1] - 1)] += 1;

			FillKwithX=true;
		}
      else if ( X[i][0] < 0 && X[i][1] > 0 && X[i][2] > 0 ) {
         Q[ (abs(X[i][0]) - 1)][ (abs(X[i][0]) - 1)] += 2;
         Q[ (abs(X[i][0]) - 1)][ (abs(X[i][1]) - 1)] -= 1;
         Q[ (abs(X[i][1]) - 1)][ (abs(X[i][0]) - 1)] -= 1;
         Q[ (abs(X[i][0]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
         Q[ (abs(X[i][2]) - 1)][ (abs(X[i][0]) - 1)] -= 1;

			FillKwithX=true;
      }
      else if ( X[i][0] > 0 && X[i][1] < 0 && X[i][2] > 0 ) {
         Q[ (abs(X[i][1]) - 1)][ (abs(X[i][1]) - 1)] += 2;
         Q[ (abs(X[i][0]) - 1)][ (abs(X[i][1]) - 1)] -= 1;
         Q[ (abs(X[i][1]) - 1)][ (abs(X[i][0]) - 1)] -= 1;
         Q[ (abs(X[i][1]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
         Q[ (abs(X[i][2]) - 1)][ (abs(X[i][1]) - 1)] -= 1;

			FillKwithX=true;
      }
      else if ( X[i][0] > 0 && X[i][1] > 0 && X[i][2] < 0 ) {
         Q[ (abs(X[i][2]) - 1)][ (abs(X[i][2]) - 1)] += 2;
         Q[ (abs(X[i][0]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
         Q[ (abs(X[i][2]) - 1)][ (abs(X[i][0]) - 1)] -= 1;
         Q[ (abs(X[i][1]) - 1)][ (abs(X[i][2]) - 1)] -= 1;
         Q[ (abs(X[i][2]) - 1)][ (abs(X[i][1]) - 1)] -= 1;

			FillKwithX=true;
      }
      else if ( X[i][0] < 0 && X[i][1] < 0 && X[i][2] > 0 ) {
			Q[ (abs(X[i][0]) - 1)][ (abs(X[i][1]) - 1)] += 1;
			Q[ (abs(X[i][1]) - 1)][ (abs(X[i][0]) - 1)] += 1;
			K[i][0] = abs(X[i][0]);
			K[i][1] = abs(X[i][1]);
			K[i][2] = abs(X[i][2]);
		}
      else if ( X[i][0] < 0 && X[i][1] > 0 && X[i][2] < 0 ) {
			Q[ (abs(X[i][0]) - 1)][ (abs(X[i][2]) - 1)] += 1;
			Q[ (abs(X[i][2]) - 1)][ (abs(X[i][0]) - 1)] += 1;

			FillKwithX=true;
      }
      else if ( X[i][0] > 0 && X[i][1] < 0 && X[i][2] < 0 ) {
			Q[ (abs(X[i][1]) - 1)][ (abs(X[i][2]) - 1)] += 1;
			Q[ (abs(X[i][2]) - 1)][ (abs(X[i][1]) - 1)] += 1;

			FillKwithX=true;
      }
      else if ( X[i][0] < 0 && X[i][1] < 0 && X[i][2] < 0 ) {			
			FillKwithX=true;
      }

		//Hier viel Code gespart
		if(FillKwithX) {			
           K[i][0] = abs(X[i][0]);
           K[i][1] = abs(X[i][1]);
           K[i][2] = abs(X[i][2]);
		}
  }

 // int Hilfsv_5 = 0;
  bool Hilfsv_5 = false;//Du verwendest Hilfsv_5 als Wahrheitswert, dann nenn es auch so.
  for (int i = 0; i < m; i++) {
		if(Hilfsv_5) break;	//wenn schon einmal  K[i][j] != 0 eingetreten dann brauch man die Schleife nicht weitermachen
      for (int j = 0; j < sat; j++) {
          if ( K[i][j] != 0 ) {
				 Hilfsv_5 = true;
				 break;	//wenn schon einmal eingetreten dann brauch man die Schleife nicht weitermachen
          }
      }
  }

  while (Hilfsv_5) {	//folgende 4 Ausdrücke sind äquivalent: while(Hilfsv_5 != 0) -> while(Hilfsv_5 != false) -> while(Hilfsv_5 == true) -> while(Hilfsv_5)
	for (int i=0; i < n; i++) {
		C[i] = 0;
	}

	  for (int i=0; i < m; i++){
			for (int j=0; j < sat; j++){
				 C[(K[i][j]-1)] += 1;
			}
	  }

	  int Hilfsv_1 = 0;
	  int Hilfsv_2;
	  for (int i=0; i < n; i++){
			if ( C[i] > Hilfsv_1 ){
				Hilfsv_1 = C[i];
				Hilfsv_2 = i + 1;
			}
	  }

	for (int i=0; i < n; i++) {
		C[i] = 0;
	}

	  for (int i=0; i < m; i++){
			if ( K[i][0] == Hilfsv_2 ) {
				C[(K[i][1]-1)] += 1;
				C[(K[i][2]-1)] += 1;
			}
			else if ( K[i][1] == Hilfsv_2 ) {
				  C[(K[i][0]-1)] += 1;
				  C[(K[i][2]-1)] += 1;
			}
			else if ( K[i][2] == Hilfsv_2 ) {
				  C[(K[i][0]-1)] += 1;
				  C[(K[i][1]-1)] += 1;
			}
	  }
	  Hilfsv_1 = 0;
	  int Hilfsv_3;
	  for (int i=0; i < n; i++){
			if ( C[i] > Hilfsv_1 ){
				Hilfsv_1 = C[i];
				Hilfsv_3 = i + 1;
			}
	  }

	  int **temp = new int*[Hilfsv_4];
	  for (int i=0; i < Hilfsv_4; i++){
			temp[i] = new int[Hilfsv_4];
	  }

	  copy2DQuadArray(Q, temp, Hilfsv_4);
	  //for (int i=0; i < Hilfsv_4; i++){
			// for (int j=0; j < Hilfsv_4; j++){
			//		temp[i][j] = Q[i][j];
			// }
	  //}

	  for (int i=0; i < Hilfsv_4; i++){
			  delete[] Q[i];
	  }
	  delete[] Q;

	  //int **Q;		//wurde schon erwähnt das Problem
	  Q = new int*[(Hilfsv_4+1)];				//Hier gibt es noch ein Problem, denn nachdem die whileschleife verlassen wird fehlt ein delete[] und zu jedem new[] gehört IIIIMMMMEEEER ein delete[]
	  for (int i=0; i < (Hilfsv_4+1); i++)
			Q[i] = new int[(Hilfsv_4+1)];

	  for (int i=0; i < Hilfsv_4; i++){
			 for (int j=0; j < Hilfsv_4; j++){
					Q[i][j] = temp[i][j];
			 }
	  }

	  for (int i=0; i < Hilfsv_4; i++){
			  delete[] temp[i];
	  }
	  delete[] temp;

	  Hilfsv_4 += 1;

	  for (int i=0; i < Hilfsv_4; i++){
			Q[(Hilfsv_4-1)][i] = 0;
	  }
	  for (int i=0; i < Hilfsv_4; i++){
			Q[i][(Hilfsv_4-1)] = 0;
	  }

	  Q[(Hilfsv_2-1)][(Hilfsv_3-1)] += P;
	  Q[(Hilfsv_3-1)][(Hilfsv_2-1)] += P;
	  Q[(Hilfsv_2-1)][(Hilfsv_4-1)] -= 2 * P;
	  Q[(Hilfsv_4-1)][(Hilfsv_2-1)] -= 2 * P;
	  Q[(Hilfsv_3-1)][(Hilfsv_4-1)] -= 2 * P;
	  Q[(Hilfsv_4-1)][(Hilfsv_3-1)] -= 2 * P;
	  Q[(Hilfsv_4-1)][(Hilfsv_4-1)] += 2 * 3 * P;

	  for (int i=0; i < m; i++){
			for (int j=0; j < sat; j++){
				if(K[i][j] == Hilfsv_2) {
					if(K[i][0] == Hilfsv_3 || K[i][1] == Hilfsv_3 || K[i][2] == Hilfsv_3) {
					  K[i][0] = 0;
					  K[i][1] = 0;
					  K[i][2] = 0;
					}
				}
				 //if ( K[i][j] == Hilfsv_2 && K[i][0] == Hilfsv_3 ){
					//  K[i][0] = 0;
					//  K[i][1] = 0;
					//  K[i][2] = 0;
				 //}
				 //else if ( K[i][j] == Hilfsv_2 && K[i][1] == Hilfsv_3 ){
					//	K[i][0] = 0;
					//	K[i][1] = 0;
					//	K[i][2] = 0;
				 //}
				 //else if ( K[i][j] == Hilfsv_2 && K[i][2] == Hilfsv_3 ){
					//	K[i][0] = 0;
					//	K[i][1] = 0;
					//	K[i][2] = 0;
				 //}
			}
	  }

	  Hilfsv_5 = false;
	  for (int i=0; i < m; i++){
			if(Hilfsv_5) break;	//wenn schon einmal  K[i][j] != 0 eingetreten dann brauch man die Schleife nicht weitermachen
			for (int j=0; j < sat; j++){
				 if ( K[i][j] != 0 ){
					Hilfsv_5 = true;
					break;	//wenn schon einmal eingetreten dann brauch man die Schleife nicht weitermachen
				 }
			}
	  }

	  //Ausgabe der Q-Matrix
	  for (int j=0; j < Hilfsv_4; j++){
			 for (int k=0;  k < Hilfsv_4; k++) {
				  cout << Q[j][k];
			  }
			  cout << endl;
	  }
  }//While ende

	//Ausgabe der Q-Matrix
	for (int j=0; j < Hilfsv_4; j++){
		for (int k=0;  k < Hilfsv_4; k++) {
			cout << Q[j][k];
		}
		cout << endl;
	}

	cout << Z;

	for (int i=0; i < Hilfsv_4; i++){ //das letzte delete...
		delete[] Q[i];
	}
	delete[] Q;

	return 0;
 }

[daddy_felix]

Baldux66 schrieb:

Im Großen und Ganzen liegt mein Problem bei den zweidimensionalen dynamischen Arrays. Ich weiß, dass es hier die Möglichkeit des Container vector gibt, wollte es aber ohne diesen hinbekommen.

Auch wenn es schon einige erwähnt haben: warum machst du dir das Leben unnötig schwer? Du hast keine Erfahrung mit C++ und willst auch kein professioneller Programmierer werden. An deiner Stelle würde ich es mir so einfach wie möglich machen.

Ich habe Informatik studiert, arbeite als Softwareentwickler und habe einige Jahre Erfahrung mit C++. Ich benutze nach Möglichkeit keine dynamischen Arrays, zweidimensionale schon gar nicht. Warum? Weil ich nicht in der Lage bin, zu garantieren, dass die Speicherveraltung zu 100% korrekt ist.

[pumuckl]

"Ich bin Heimwerker ohne Vorkenntnisse. Ich will mir eine Brücke über meinen Teich bauen, aber nicht so einen Bausatz aus dem Baumarkt. Ich hab versucht, mit geflochtenen Streichölzern eine Bogenbrücke zu bauen, aber das dumme Ding stürzt immer zusammen. Ich hab nicht wirklich Ahnung von Statik, kann mir wer helfen?"

Merkst was?

[Fawkes1234]

vor (return 0;)

eine while schleife erstellen die solange läuft, bis das programm beendet wird oder ein bestimmtes ereignis eintritt. Bei mir hat es den Fehler gelöst ich hoffe bei dir klappts auch

[Furble Wurble]

Baldux66 schrieb:

Im Großen und Ganzen liegt mein Problem bei den zweidimensionalen dynamischen Arrays.

Meiner bescheidenen Meinung nach liegt das Problem an dem Spaghetticode, den niemand - ausser Dir? - versteht.
Ein bißchen Objektorientierung und - vector hin oder her - das Ding ist nicht mehr halb so grausig wie jetzt.
Ich bin mir auch sicher, dass hier viele mit Begeisterung bei der Lösung des Problems helfen vürden, wenn klar wäre, was das Ding denn machen soll...