C++ Absturz und keine Idee wieso

M--G · 20. Juni 2011

Hallo,
kompilieren klappt wunderbar, aber wieso das Programm abstürzt ist mir ein Rätsel.
Hat einer eine Idee?
(das Code-Fragment macht aus vier Pixeln einen)

"Auto Chrom.exe": "D:\Auto Chrom\Debug\Auto Chrom.exe" geladen, Symbole wurden geladen.
"Auto Chrom.exe": "C:\WINDOWS\system32\ntdll.dll" geladen, Cannot find or open the PDB file
"Auto Chrom.exe": "C:\WINDOWS\system32\kernel32.dll" geladen, Cannot find or open the PDB file
"Auto Chrom.exe": "C:\WINDOWS\system32\msvcp100d.dll" geladen, Symbole wurden geladen.
"Auto Chrom.exe": "C:\WINDOWS\system32\msvcr100d.dll" geladen, Symbole wurden geladen.
Eine Ausnahme (erste Chance) bei 0x0041165b in Auto Chrom.exe: 0xC0000005: Zugriffsverletzung beim Schreiben an Position 0x015c8a98.
Unbehandelte Ausnahme bei 0x0041165b in Auto Chrom.exe: 0xC0000005: Zugriffsverletzung beim Schreiben an Position 0x015c8a98.
Das Programm "[552] Auto Chrom.exe: Systemeigen" wurde mit Code 0 (0x0) beendet.

Irgendeine Lösungsidee?
Selbst mit 2x zwei forschleifen tritt das Problem auf.
(in einer wird der Mittelwert berechnet, und ganz danach erst der Mittelwert in das alte Feld geschrieben.)

Code:

Cluster: 
if (awc==1) 
    {int f=1; int g=1; //f entspricht x und g entspricht y 
    for (int i=1; i<=ymax-1; i=i+2) 
         {for (int j=1; j<=xmax-1; j=j+2) 
              {            
              Hs[f][g]=(H[j][i]+H[j+1][i]+H[j][i+1]+H[j+1][i+1])/4; 
              Ss[f][g]=(S[j][i]+S[j+1][i]+S[j][i+1]+S[j+1][i+1])/4;           
              Vs[f][g]=(V[j][i]+V[j+1][i]+V[j][i+1]+V[j+1][i+1])/4; 
          
              H[f][g]=Hs[f][g]; 
              S[f][g]=Ss[f][g]; 
              V[f][g]=Vs[f][g]; 
                    
              f=f+1; 
              } 
         g=g+1; 
         } 
          
    clust = clust+1; 
    xr = xr/2; 
    yr = yr/2; 

    cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl; 
    cout << endl <<"      Bild erfolgreich zum " << clust << "ten mal geclustert     " << endl; 
    cout << endl <<"        aktuelle Aufloesung: " << xr << " x " << yr << " Pixel" << endl; 
    cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;   

    awc=0; 

    if (wka==1) 
        {wka=0; 
        goto KalAuswerten;} 

    else // if (wa==1) 
        {wa=0; 
        goto Auswerten;} 
    }

DaZpoon · 20. Juni 2011

Für solche Fälle wurde der Debugger erfunden... Einfach mal bis zum Punkt wo es knallt durchsteppen und dann Variablen begutachten.

Apropos: Labels + Goto? Omg.

yama03061989 · 20. Juni 2011

warum schreibst du keine einzelnen funktionen, zur not auch mit globalen variablen, dann hast du das problem nicht mit den parametern.

Goto sollte man am besten vermeiden, lieber einzelne funktionsaufrufe.

BrainFart · 20. Juni 2011

Vermutlich liegt das Problem in den Dimensionen deiner Matrizen H/S/V bzw. Hs/Ss/Vs, zeig mal deren Deklaration... Ansonsten hat DaZpoon recht: Goto ist gaaaaaanz böse, sollte man vermeiden, es sei denn, man weiß genau, was man tut... Gut möglich, dass der Fehler durch das Goto verursacht wird...

M--G · 20. Juni 2011

Das Problem ist, dass ich ganze Arrays am Ende der Funktion zurückgeben (return) müsste, was wohl ohne weiteres nicht möglich ist!

//initiere alle Speicherarrays
double ROT[xmax+1][ymax+1]; double GRUEN[xmax+1][ymax+1]; double BLAU[xmax+1][ymax+1];
double H[xmax+1][ymax+1]; double S[xmax+1][ymax+1]; double V[xmax+1][ymax+1];

double Hs[xmax+1][ymax+1]; double Ss[xmax+1][ymax+1]; double Vs[xmax+1][ymax+1];
double Hm[xmax+1][ymax+1]; double Sm[xmax+1][ymax+1]; double Vm[xmax+1][ymax+1];

yama03061989 · 20. Juni 2011

wenn du das array aber als global deklarierst, sprich vor der main funktion dann brauchst du auch keine array zurückgeben, weil jeder teil vom programm das array verändern kann! das habe ich vorhins gemeint

das ist nurn Bsp., natürlich primitiver:

Code:

//Deklaration vor der main

int array[20][20];
void auswerten(void);


void main(void)
{
 auswerten();
 printf("%d",array[20][20]); //ist dann 30 siehe Funktion auswerten()
}

void auswerten()
{
 array[20][20] = 30;  //Reihe 20, enthält im 20 Element den Wert 30
}

fertig! versuche doch einmal das array als global zu deklarieren.
das einzige problem was ich hier sehen würde ist das du den arrays feste werte zuweisen müsstest.

BlackMark · 20. Juni 2011

Du kannst das Array als Parameter übergeben, dann musst du keine globalen Variablen verwenden.
Beispiel:

Code:

void returnArray( int* piArray, unsigned int uiSize )
{
     piArray[0] = 1;
}

int main()
{
     unsigned int uiSize = 2;
     int* piArray = new int[uiSize];

     piArray[0] = 0;
     piArray[1] = 0;

     returnArray( piArray, uiSize );

     // piArray[0] == 1;
}

Damit solltest du globale Variablen vermeiden können!

Gruß
BlackMark

BrainFart · 20. Juni 2011

OK, die Deklarationen der Arrays scheinen erstmal in Ordnung zu sein...

yama03061989 schrieb:
wenn du das array aber als global deklarierst, sprich vor der main funktion dann brauchst du auch keine array zurückgeben, weil jeder teil vom programm das array verändern kann! das habe ich vorhins gemeint

Naja, globale Variablen sind eine "So-la-la"-Lösung... Nicht schön, aber funktioniert bei einfachen Programmen...

In C würde man die Zielmatrix in der aufrufenden Funktion erzeugen und einen Zeiger an Auswerten() übergeben:

Code:

void Auswerten(double **h, double **s, double **v, int Xmax, int Ymax)
{
   ...
}

int main()
{
   ... //Definition von H/S/V

  Auswerten(H, S, V, xmax, ymax);

}

In C++ wäre es besserer Stil, die entspr. STL-Klassen, wie std::vector<>, zu verwenden...

M--G · 20. Juni 2011

Wieso habe ich mich gestern überhaupt im größten C++ Forum rumgeärgert, wenn mir hier viel besser geholfen wird?
Habe gestern alles vom Funktionsaufbau auf Sprungmarken umgebaut *grummel*

Leider rennt mir die Zeit von meiner Studienarbeit davon (Verfahrenstechnik und nicht(!) Infomatik). Und da ich schon immer mit Pointern auf dem Kriegsfuß war, würde ich demjenigen die Füße küssen, der mir exemplarisch eine der Sprung"funktionen" kurz verpointert und dort reinschreibt wo es hingehört.
(die restlichen sollte ich dann hinbekommen...)

Vielen vielen vielen Dank schonmal!

Hier mein bisheriges Verbrechen:

Code:

#include <iostream>
#include <iomanip>

#include <math.h>
//#include <CImg.h>

// #include <cv.h>
// #include <cxcore.h>
// #include <highgui.h>

// #include <cstdlib>
// #include <conio.h> 

using namespace std;
    
//initiere alle Speicherarrays
const int xmax=400; const int ymax=400;
double ROT[xmax+1][ymax+1]; double GRUEN[xmax+1][ymax+1]; double BLAU[xmax+1][ymax+1];
double H[xmax+1][ymax+1]; double S[xmax+1][ymax+1]; double V[xmax+1][ymax+1];

double Hs[xmax+1][ymax+1]; double Ss[xmax+1][ymax+1]; double Vs[xmax+1][ymax+1];
double Hm[xmax+1][ymax+1]; double Sm[xmax+1][ymax+1]; double Vm[xmax+1][ymax+1];

int main()

{
int xr = 400; int yr = 400; //reale Auflösung

int hsv=0; //Schalter, ob HSV-Konvertierung durchgeführt
int clust=0;

//waypoints für das Auswerten, Kalibrieren....
int wa=0; int wka=0;

//aktive waypoints fürs clustern, fehlerpixel und rgb in hsv
int awc=0; int awf=0; int awh=0;

/*	if (hsv==1)
	{cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl;
		cout << endl <<"   Bild wurde bereits in HSV-Spektrum umgewandelt   " << endl;
		cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;  
		return 0;
		}
*/

Cluster:
if (awc==1)
	{int f=1; int g=1; //f entspricht x und g entspricht y
	for (int i=1; i<=yr-1; i=i+2)
		 {for (int j=1; j<=xr-1; j=j+2)
			  {	        
			  Hs[f][g]=(H[j][i]+H[j+1][i]+H[j][i+1]+H[j+1][i+1])/4;
			  Ss[f][g]=(S[j][i]+S[j+1][i]+S[j][i+1]+S[j+1][i+1])/4;          
			  Vs[f][g]=(V[j][i]+V[j+1][i]+V[j][i+1]+V[j+1][i+1])/4;
                    
			  f=f+1;
			  }
		 g=g+1;
		 }

	xr = xr/2;
	yr = yr/2;		

	for (int i=1; i<=yr-1; i=i+1)
		 {for (int j=1; j<=xr-1; j=j+1)
			  {	        
			  H[j][i]=Hs[j][i];
			  S[j][i]=Ss[j][i];
			  V[j][i]=Vs[j][i];
			  }
		}
         
	clust = clust+1;

	cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;
	cout << endl <<"      Bild erfolgreich zum " << clust << "ten mal geclustert     " << endl;
	cout << endl <<"        aktuelle Aufloesung: " << xr << " x " << yr << " Pixel" << endl;
	cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;  

	awc=0;

	if (wka==1)
		{wka=0;
		goto KalAuswerten;}

	else //if (wa==1)
		{wa=0;
		goto Auswerten;}

	}

RGBinHSV:
if (awh==1)
	{double MAX=0; double MIN=0;

	for (int i=1; i<=ymax+1; i++)
		 {for (int j=1; j<=xmax+1; j++)
			  {//setzt R,B,B auf 0=false und 1=MAX 2=MIN
			  int R=0; int G=0; int B=0;
          
				   if (ROT[j][i]>BLAU[j][i] && ROT[j][i]>GRUEN[j][i]) 
				   {MAX=ROT[j][i]; R=1;
				   }   
				   if (GRUEN[j][i]>ROT[j][i] && GRUEN[j][i]>BLAU[j][i]) 
				   {MAX=GRUEN[j][i]; G=1;
				   }           
				   if (BLAU[j][i]>ROT[j][i] && BLAU[j][i]>GRUEN[j][i]) 
				   {MAX=BLAU[j][i]; B=1;
				   }                           
               
				   if (ROT[j][i]<BLAU[j][i] && ROT[j][i]<GRUEN[j][i]) 
				   {MAX=ROT[j][i]; R=2;
				   }
				   if (GRUEN[j][i]<ROT[j][i] && GRUEN[j][i]<BLAU[j][i]) 
				   {MAX=GRUEN[j][i]; G=2;
				   }              
				   if (BLAU[j][i]<ROT[j][i] && BLAU[j][i]<GRUEN[j][i]) 
				   {MAX=BLAU[j][i]; B=2;
				   }    
                                      
				   if (MIN=MAX) 
				   {H[j][i]=0;
				   }             
				   else if(R=1)
				   {H[j][i]=60*(0+(GRUEN[j][i]-BLAU[j][i])/(MAX-MIN));
				   }
				   else if(G=1)
				   {H[j][i]=60*(2+(BLAU[j][i]-ROT[j][i])/(MAX-MIN));
				   }          
				   else //(B=1)
				   {H[j][i]=60*(4+(ROT[j][i]-GRUEN[j][i])/(MAX-MIN));
				   }          
          
				   S[j][i]=(MAX-MIN)/MAX;
				   V[j][i]=MAX/255;     
			  }
		 }
	awh=0;
	hsv=1;  

	cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl;
	cout << endl <<"   Bild erfolgreich in HSV-Spektrum umgewandelt    " << endl;
	cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;

	if (wka==1)
		{wka=0;
		goto KalAuswerten;}

	else //if (wa==1)
		{wa=0;
		goto Auswerten;}
	}

Fehler:
if (awf==1)
	{int t=10;
	int fehl=0;
	cout << endl <<"Bitte Abweichungstoleranz in Prozent eingeben:" << endl << endl;
	cin >> t;

	t=1+t/10;
	

		for (int i=2; i<=yr-1; i++)
		 {for (int j=2; j<=xr-1; j++)
			  {	          
			  Hm[j][i]=(H[j-1][i-1]+H[j][i-1]+H[j+1][i-1]+H[j-1][i]+H[j+1][i]+H[j-1][i+1]+H[j][i+1]+H[j+1][i+1])/8;
			  Sm[j][i]=(S[j-1][i-1]+S[j][i-1]+S[j+1][i-1]+S[j-1][i]+S[j+1][i]+S[j-1][i+1]+S[j][i+1]+S[j+1][i+1])/8;      
			  Vm[j][i]=(V[j-1][i-1]+V[j][i-1]+V[j+1][i-1]+V[j-1][i]+V[j+1][i]+V[j-1][i+1]+V[j][i+1]+V[j+1][i+1])/8;;


				   if (H[j][i] >= Hm[j][i]*t) 
				   {H[j][i] = Hm[j][i];
				   fehl=fehl+1; //nur die H-Fehlerpixel interessant!
				   }  
				   if (S[j][i] >= Sm[j][i]*t) 
				   {S[j][i] = Sm[j][i];				   
				   }  
				   if (V[j][i] >= Vm[j][i]*t) 
				   {V[j][i] = Vm[j][i];				   
				   }            
			  }
		 }

	cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;
	cout << endl <<"         Fehlerpixel erfolgreich entfernt          " << endl;
	cout << endl <<"                   " << fehl << " Fehlerpixel           " << endl;
	cout << endl <<"       aktuelle Aufloesung: " << xr << " x " << yr << " Pixel" << endl;
	cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;  

	awf=0;

	if (wka==1)
		{wka=0;
		goto KalAuswerten;}

	else //if (wa==1)
		{wa=0;
		goto Auswerten;}
	}

//-------------------------------------------
//HIER BEGINNT DAS EIGENTLICHE PROGRAMM:
//-------------------------------------------

    
int pause;

Hauptmenue:
cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl; //Trennstrich 
cout << " [ Hauptmenue ] " << endl << endl;      
cout << "(1) Kalibrierung durchfuehren" << endl;
cout << "(2) Bild auswerten" << endl;
cout << "(3) Beenden" << endl << endl;

char a; char b; char c;
cin >> a;

cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl; //Trennstrich 

    if (a == '1') 
		   {Kalibrieren:
			cout << endl <<  " [ Kalibrierung ] " << endl << endl;
			cout << "(1) neues Bild hinzufuegen" << endl;
			cout << "(2) Daten anzeigen" << endl;
			cout << "(3) Daten loeschen" << endl;
			cout << "(4) zurueck zum Hauptmenue" << endl << endl;

			cin >> b;
       
			   if (b == '1')
					{cout << endl <<  "Bitte die Temperatur in " << char(248) << "C eingeben [mit Punkt zur Dezimaltrennung]:" << endl << endl;
		   			double bildtemp;
					cin >> bildtemp;

					cout << endl <<  "Bitte den Namen des Bildes eingeben:" << endl << endl;
					char  bildname;
					cin >> bildname;

					clust=0;
					hsv=0;
					wka=1; wa=0;
					awh=1;

					goto RGBinHSV;

					KalAuswerten:
					cout << "(1) Kalibrierung durchfuehren" << endl;
					cout << "(2) Bildpunkte clustern" << endl;
					cout << "(3) Fehlerpixel entfernen" << endl;
					cout << "(4) zurueck zum vorherigen Menue" << endl;
					cout << "(5) zurueck zum Hauptmenue" << endl << endl;
			
					cin >> c;

						if (c == '1')
							{//Auswerten();
							}	
						else if (c == '2')
							{awc=1;
							goto Cluster;
							} 
						else if (c == '3')
							{awf=1;
							goto Fehler;
							} 
						else if (c == '4')
							{goto Kalibrieren;
							} 
						else {goto Hauptmenue;
							}  


					}

			   else if (b == '2')
					{cout << endl <<  " [ Kalibrierungsdaten ] " << endl << endl;
					//cout DATEN
					 cout << "(1) Daten ausdrucken" << endl;
					 cout << "(2) zurueck zum Hauptmenue" << endl << endl;

					 cin >> c;

						 if (c == '1')
							{
							} 
						else {goto Hauptmenue;
							}  
					}	
			   else if (b == '3')
					{
					} 
			   else {goto Hauptmenue;
					}   
		   }

    else if (a == '2') 
         {cout << endl <<  " [ Bilderauswertung ] " << endl << endl;
 		 cout << endl <<  "Bitte Name des Bildes eingeben:" << endl << endl;

		//std::string  bildname;
		//cin >> bildname;

		 hsv=0;
		 clust=0;

		 if (hsv==0)
			{awh=1;
			wa=1; wka=0;

			goto RGBinHSV;
			}
		 
			Auswerten:
			cout << "(1) auswerten" << endl;
			cout << "(2) Bildpunkte clustern" << endl;
			cout << "(3) Fehlerpixel entfernen" << endl;
			cout << "(4) zurueck zum Hauptmenue" << endl << endl;
			
			cin >> b;

				if (b == '1')
					{//Auswerten();
					}	
				else if (b == '2')
					{awc=1;
					goto Cluster;
					} 
				else if (b == '3')
					{awf=1;
					goto Fehler;
					} 
				else {goto Hauptmenue;
					}  
         }

    else {cout << endl <<  "Programm wird beendet, weiter mit beliebiger Taste" << endl << endl;
         cin >> pause;
         return 0;
         }

cout << endl <<  "Programm wird beendet, weiter mit beliebiger Taste" << endl << endl;
cin >> pause;

return 0;
}

BrainFart · 20. Juni 2011

Ok, das ist jetzt echt ziemlich viel verlangt, weil man bei deinem Code schon nicht mehr durchblickt... (genau deswegen spricht man bei Gotos von "Spaghetticode", lol)...
Mal ein Versuch:

Code:

void RGBinHSV(double **ROT, double **GRUEN, double **BLAU, double **H, double **S, double **V, int xmax, int ymax)
{
    double MAX=0; double MIN=0;

    //Du kannst hier mit den Pointern genau wie mit Arrays arbeiten, weil in C/C++ der Name eines Arrays gleichbedeutend 
    //mit einem Zeiger auf das erste Element ist: ROT = &ROT[0][0]

    for (int i=1; i<=ymax+1; i++)
    {
        for (int j=1; j<=xmax+1; j++)
        {//setzt R,B,B auf 0=false und 1=MAX 2=MIN
              int R=0; int G=0; int B=0;
          
                   if (ROT[j][i]>BLAU[j][i] && ROT[j][i]>GRUEN[j][i]) 
                   {MAX=ROT[j][i]; R=1;
                   }   
                   if (GRUEN[j][i]>ROT[j][i] && GRUEN[j][i]>BLAU[j][i]) 
                   {MAX=GRUEN[j][i]; G=1;
                   }           
                   if (BLAU[j][i]>ROT[j][i] && BLAU[j][i]>GRUEN[j][i]) 
                   {MAX=BLAU[j][i]; B=1;
                   }                           
               
                   if (ROT[j][i]<BLAU[j][i] && ROT[j][i]<GRUEN[j][i]) 
                   {MAX=ROT[j][i]; R=2;
                   }
                   if (GRUEN[j][i]<ROT[j][i] && GRUEN[j][i]<BLAU[j][i]) 
                   {MAX=GRUEN[j][i]; G=2;
                   }              
                   if (BLAU[j][i]<ROT[j][i] && BLAU[j][i]<GRUEN[j][i]) 
                   {MAX=BLAU[j][i]; B=2;
                   }    
                                      
                   if (MIN=MAX) 
                   {H[j][i]=0;
                   }             
                   else if(R=1)
                   {H[j][i]=60*(0+(GRUEN[j][i]-BLAU[j][i])/(MAX-MIN));
                   }
                   else if(G=1)
                   {H[j][i]=60*(2+(BLAU[j][i]-ROT[j][i])/(MAX-MIN));
                   }          
                   else //(B=1)
                   {H[j][i]=60*(4+(ROT[j][i]-GRUEN[j][i])/(MAX-MIN));
                   }          
          
                   S[j][i]=(MAX-MIN)/MAX;
                   V[j][i]=MAX/255;     
              }
         }

    cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl;
    cout << endl <<"   Bild erfolgreich in HSV-Spektrum umgewandelt    " << endl;
    cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;

}

int main()
{
    //Definition der Arrays, Kleinschrift, um zwischen denen in main() und RGBinHSV zu unterscheiden,
    // spielt aber eigentlich keine Rolle, weil beide unterschiedliche Gültigkeitsbereiche haben

    double rot[xmax+1][ymax+1]; double gruen[xmax+1][ymax+1]; double blau[xmax+1][ymax+1];
    double h[xmax+1][ymax+1]; double s[xmax+1][ymax+1]; double v[xmax+1][ymax+1];

    ...

    //hier übergibst du dann Quell und Zielarray
    RGBinHSV(rot, gruen, blau, h, s, v, xmax, ymax);
}

M--G · 20. Juni 2011

Danke

mich begeistert ans Werk gemacht....

p.s. ich hasse inzwischen Spaghettis & Pointer

Der verkürzte Code:

Code:

#include <iostream>
#include <iomanip>

#include <math.h>
//#include <CImg.h>

// #include <cv.h>
// #include <cxcore.h>
// #include <highgui.h>

// #include <cstdlib>
// #include <conio.h> 

using namespace std;
    
//initiere alle Speicherarrays
const int xmax=400; const int ymax=400;

    double rot[xmax+1][ymax+1]; double gruen[xmax+1][ymax+1]; double blau[xmax+1][ymax+1];
    double H[xmax+1][ymax+1]; double S[xmax+1][ymax+1]; double V[xmax+1][ymax+1];

	double Hs[xmax+1][ymax+1]; double Vs[xmax+1][ymax+1]; double Vs[xmax+1][ymax+1];
	double Hm[xmax+1][ymax+1]; double Sm[xmax+1][ymax+1]; double Vm[xmax+1][ymax+1];

void RGBinHSV(double **ROT, double **GRUEN, double **BLAU, double **H, double **S, double **V, int xmax, int ymax)
{
    double MAX=0; double MIN=0;

    //Du kannst hier mit den Pointern genau wie mit Arrays arbeiten, weil in C/C++ der Name eines Arrays gleichbedeutend 
    //mit einem Zeiger auf das erste Element ist: ROT = &ROT[0][0]

    for (int i=1; i<=ymax+1; i++)
    {
        for (int j=1; j<=xmax+1; j++)
        {//setzt R,B,B auf 0=false und 1=MAX 2=MIN
              int R=0; int G=0; int B=0;
          
                   if (ROT[j][i]>BLAU[j][i] && ROT[j][i]>GRUEN[j][i]) 
                   {MAX=ROT[j][i]; R=1;
                   }   
                   if (GRUEN[j][i]>ROT[j][i] && GRUEN[j][i]>BLAU[j][i]) 
                   {MAX=GRUEN[j][i]; G=1;
                   }           
                   if (BLAU[j][i]>ROT[j][i] && BLAU[j][i]>GRUEN[j][i]) 
                   {MAX=BLAU[j][i]; B=1;
                   }                           
               
                   if (ROT[j][i]<BLAU[j][i] && ROT[j][i]<GRUEN[j][i]) 
                   {MAX=ROT[j][i]; R=2;
                   }
                   if (GRUEN[j][i]<ROT[j][i] && GRUEN[j][i]<BLAU[j][i]) 
                   {MAX=GRUEN[j][i]; G=2;
                   }              
                   if (BLAU[j][i]<ROT[j][i] && BLAU[j][i]<GRUEN[j][i]) 
                   {MAX=BLAU[j][i]; B=2;
                   }    
                                      
                   if (MIN=MAX) 
                   {H[j][i]=0;
                   }             
                   else if(R=1)
                   {H[j][i]=60*(0+(GRUEN[j][i]-BLAU[j][i])/(MAX-MIN));
                   }
                   else if(G=1)
                   {H[j][i]=60*(2+(BLAU[j][i]-ROT[j][i])/(MAX-MIN));
                   }          
                   else //(B=1)
                   {H[j][i]=60*(4+(ROT[j][i]-GRUEN[j][i])/(MAX-MIN));
                   }          
          
                   S[j][i]=(MAX-MIN)/MAX;
                   V[j][i]=MAX/255;     
              }
         }

    cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl;
    cout << endl <<"   Bild erfolgreich in HSV-Spektrum umgewandelt    " << endl;
    cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl;
}


int main()

{
int xr = 400; int yr = 400; //reale Auflösung


//-------------------------------------------
//HIER BEGINNT DAS EIGENTLICHE PROGRAMM:
//-------------------------------------------


int pause;

Hauptmenue:
cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl; //Trennstrich 
cout << " [ Hauptmenue ] " << endl << endl;      
cout << "(1) Kalibrierung durchfuehren" << endl;
cout << "(2) Bild auswerten" << endl;
cout << "(3) Beenden" << endl << endl;

char a; char b; char c;
cin >> a;

cout << endl <<"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _" << endl << endl; //Trennstrich 

    if (a == '1') 
		   {Kalibrieren:
			cout << endl <<  " [ Kalibrierung ] " << endl << endl;
			cout << "(1) neues Bild hinzufuegen" << endl;
			cout << "(2) Daten anzeigen" << endl;
			cout << "(3) Daten loeschen" << endl;
			cout << "(4) zurueck zum Hauptmenue" << endl << endl;

			cin >> b;
       
			   if (b == '1')
					{cout << endl <<  "Bitte die Temperatur in " << char(248) << "C eingeben [mit Punkt zur Dezimaltrennung]:" << endl << endl;
		   			double bildtemp;
					cin >> bildtemp;

					cout << endl <<  "Bitte den Namen des Bildes eingeben:" << endl << endl;
					char  bildname;
					cin >> bildname;


					RGBinHSV (rot, gruen, blau, H, S, V, xmax, ymax);



return 0;
}

Die Errors:

------ Erstellen gestartet: Projekt: Auto Chrom, Konfiguration: Debug Win32 ------
Programm.cpp
d:\auto chrom\auto chrom\programm.cpp(23): error C2086: 'double Vs[401][401]': Neudefinition
d:\auto chrom\auto chrom\programm.cpp(23): Siehe Deklaration von 'Vs'
d:\auto chrom\auto chrom\programm.cpp(104): error C2065: 'Ss': nichtdeklarierter Bezeichner
d:\auto chrom\auto chrom\programm.cpp(119): error C2065: 'Ss': nichtdeklarierter Bezeichner
d:\auto chrom\auto chrom\programm.cpp(243): error C2664: 'RGBinHSV': Konvertierung des Parameters 1 von 'double [401][401]' in 'double **' nicht möglich
Die Typen, auf die verwiesen wird, sind nicht verknüpft; die Konvertierung erfordert einen reinterpret_cast-Operator oder eine Typumwandlung im C- oder Funktionsformat.
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

BrainFart · 20. Juni 2011

Code:

	double Hs[xmax+1][ymax+1]; double Vs[xmax+1][ymax+1]; double Vs[xmax+1][ymax+1];

Da stecken die ersten 3 Fehler

Für den anderen wird's ein bisschen komplizierter... War ein Denkfehler meinerseits, bzgl. der Speicherorganisation mehrdimensionaler Arrays, die höheren Dimensionen müssen nämlich zur Compilezeit bekannt sein...

Code:

//initiere alle Speicherarrays
const int xmax=400; const int ymax=400;

...

void RGBinHSV(double **ROT, double **GRUEN, double **BLAU, double **H, double **S, double **V, int xmax, int ymax)

...kannst du in:

Code:

//initiere alle Speicherarrays
#define DIMX 401
#define DIMY 401

const int xmax=DIMX - 1; const int ymax=DIMY - 1;
...

void RGBinHSV(double ROT[DIMX][DIMY], double GRUEN[DIMX][DIMY], double BLAU[DIMX][DIMY], double H[DIMX][DIMY], double S[DIMX][DIMY], double V[DIMX][DIMY], int xmax, int ymax)

...umbauen. Erklärung: XMAX und YMAX werden vom Präprozessor bereits vor dem Kompilieren durch die entspr. Werte ersetzt, für den Compiler stehen dort also konstante Array-Dimensionen, also weiß er, wie er die Arrays im Speicher organisieren muss... Da xmax und ymax bei dir ja bereits zur Compilezeit bekannt sind, ist es die einfachste Lösung...

M--G · 20. Juni 2011

Super, vielen vielen Dank!!!
Läuft nun fehlerfrei und der Inhalt bleibt auch nach dem Feld erhalten!

Um damit er mir xr, clust... auch in den Funktionen ändert, muss ich sie auch als array nutzen?!

Sooo, dann habe ich nach dem Mittagessen ja was zu tun und danach geht es erst richtig mit dem Programm los

Danke nochmal!

voodoo44 · 20. Juni 2011

Code:

if (MIN=MAX)

Funktioniert das unter C++? Sollte doch gar nicht - oder hab ich innerhalb von 3 Jahren schon wieder so viel vergessen?

antred · 20. Juni 2011

voodoo44 schrieb:
Code:

if (MIN=MAX)

Funktioniert das unter C++? Sollte doch gar nicht - oder hab ich innerhalb von 3 Jahren schon wieder so viel vergessen?

Soweit MIN eine zuweisbare Variable ist, "funktioniert" das schon. Nur tut es eben nicht, was der Autor vermutlich damit bezwecken wollte.

M--G · 20. Juni 2011

Muss da ein == hin?
Auch darunter oder passt das da?

Wenn das Programm läuft, bin ich wahnsinnig

Wobei das meiste ja noch fehlt *gg*

antred · 20. Juni 2011

M--G schrieb:
Muss da ein == hin?

Wenn du MIN und MAX auf Gleichheit prüfen möchtest, ja. Ein einfaches = ist eine Zuweisung.

M--G · 20. Juni 2011

Tja, da steckt Visual Basic noch gaaaanz tief in mir drin

Danke für den Hinweis!

voodoo44 · 20. Juni 2011

antred schrieb:
Soweit MIN eine zuweisbare Variable ist, "funktioniert" das schon.

Ich wollte damit auf das doppelte Gleichheitszeichen raus

M--G · 20. Juni 2011

Ok soweit alles umgeschrieben.
Der Fehler, weshalb ich den Thread gestartet habe, tritt aber leider immernoch auf!

Konnte den Fehler jetzt auf dieses Programmstück zurückverfolgen:
Wobei Yreal=Xreal=400 (anders als davor, aber gleicher Fehler/Absturz)
Und die Arrays jeweeils [401][401] groß sind, also 400 Speicherplätze ab 1 haben.

Code:

int f=1; int g=1; //f entspricht x und g entspricht y

	for (int i=1; i<Yreal[0]; i=i+2)
		 {for (int j=1; j<Xreal[0]; j=j+2)
			  {	        
			  Hs[f][g]=(H[j][i]+H[j+1][i]+H[j][i+1]+H[j+1][i+1])/4;
			  Ss[f][g]=(S[j][i]+S[j+1][i]+S[j][i+1]+S[j+1][i+1])/4;          
			  Vs[f][g]=(V[j][i]+V[j+1][i]+V[j][i+1]+V[j+1][i+1])/4;
                    
			  f=f+1;
			  }
		 g=g+1;
		 }

Kann also nicht an den GoTo liegen, wie anfangs vermutet

Hilft mir aber auch nicht weiter:
Selbst wenn ich die Forschleifen nur bis 399 laufen lasse, stürzt es ab!

Na sagt doch schon die Fehlermeldung, du schreibst über den reservierten Speicher hinaus, oder zumindest auf eine Adresse die du nicht Reserviert hast. Also wirst du schauen müssen an welcher Stelle du eine Speicherüberschreitung hast, sollte dir aber der Compiler anzeigen wo das Problem auftritt.

Ergänzung (21. Juni 2011)

Fehler gefunden

Da hat was wichtiges gefehlt

Code:

	for (int i=1; i<Yreal[0]; i=i+2)
		 {[COLOR="Red"]f=1[/COLOR];
                                   for (int j=1; j<Xreal[0]; j=j+2)
			  {	        
			  Hs[f][g]=(H[j][i]+H[j+1][i]+H[j][i+1]+H[j+1][i+1])/4;
			  Ss[f][g]=(S[j][i]+S[j+1][i]+S[j][i+1]+S[j+1][i+1])/4;          
			  Vs[f][g]=(V[j][i]+V[j+1][i]+V[j][i+1]+V[j+1][i+1])/4;
                    
			  f=f+1;
			  }
		 g=g+1;
		 }

C++ Absturz und keine Idee wieso

Lieutenant

Captain

Lt. Commander

Ensign

Lieutenant

Lt. Commander

Lt. Commander

Ensign

Lieutenant

Ensign

Lieutenant

Ensign

Lieutenant

Lieutenant

Lt. Commander

Lieutenant

Lt. Commander

Lieutenant

Lieutenant

Lieutenant

Ähnliche Themen