[bb83]

Ich habe ein Problem mit folgendem programm:

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <limits.h> //architektur
#include <stdlib.h>
#define true  0


int fehlercode (char **fehlermeldung);

int main(){

	char **fehlermeldung;

	fehlercode(fehlermeldung);
	printf("%s",*fehlermeldung);

}


int fehlercode (char **fehlermeldung) {

	unsigned int max,i=0;
	int a,b;
	double zahl,maxx;
	char eingabe[300];
	

	printf("\nBitte geben sie irgendeine Zeichenkette ein\n");
	fflush(stdin);
	fgets(eingabe,300, stdin);
	if(eingabe == NULL) return 1;
   if((eingabe[0] == '+')) return 1;		//Verhindert akzeptanz von +
	if((eingabe[0] == '-'))i++;				//Erlaubt - (eigentlich Unsinn)
   
	while(eingabe[i] != '\n')
   	if(!isdigit(eingabe[i++])){				//Ueberprueft nach und nach den Array ob er aus Zahlen besteht
			*fehlermeldung="Buchstabe";  
			 
			return 1;}
							//Rueckgabe von "false" wenn Buchstabe oder + im string
	

	max=(UINT_MAX); 			//Einlesen der maximalen Groesse von unsigned integer
	zahl= atof(eingabe); 	//Umwandlung des Strings in einen Double Wert
	maxx=(double)max;

	if (zahl>max){
		printf("zahl zu gro�");
		*fehlermeldung="Die Zahl ist leider zu gro�";
		return 1;	//Wenn Zahl groesser unsigned int dann return 1
		}
	
	if (zahl<0){
		*fehlermeldung="Zahl kleiner 0";
		return 1;	//Wenn Zahl kleiner 0 return 1
		}	

	*fehlermeldung="Alles i.O.";	
}

Unter Unix läuft das ganze perfekt, wenn ich das ganze unter Linux/Windows ausführen möchte bekomme ich einen Segmentation Error. Kann mir wer sagen woran das liegt.

Compiler wirft keine Fehlermeldung raus!

Dieser Beitrag wurde von bbrickwedde bearbeitet: 08. November 2006 - 22:21

[Rika]

Wie wär's, wenn du mal Debug-Code erzeugst bzw. einen Debugger verwendest bzw. einen Stack Trace erzeugst?

Ich würde auf zwei Stellen tippen:
fgets(eingabe,300, stdin); und if(!isdigit(eingabe[i++])){

[bb83]

Stackdump:

Exception: STATUS_ACCESS_VIOLATION at eip=610DD714
eax=00000042 ebx=00000000 ecx=5DE58955 edx=0040202F esi=610FF1A0 edi=5DE58955
ebp=0022CB38 esp=0022CB2C program=D:\cygwin\home\Bastian\prototyp52.exe, pid 2380, thread main
cs=001B ds=0023 es=0023 fs=003B gs=0000 ss=0023
Stack trace:
Frame	 Function  Args
0022CB38  610DD714  (5DE58955, 0040202E, 61100070, 61052D08)
0022CCB8  0040114F  (00401500, 0022CE64, 00401050, 00401075)
0022CCE8  00401085  (00000001, 6116768C, 00660090, 0022CC70)
0022CD98  61006168  (00000000, 0022CDD0, 610054E0, 0022CDD0)
610054E0  61004416  (0000009C, A02404C7, E8610FF1, FFFFFF48)
	 10 [main] prototyp52 2380 _cygtls::handle_exceptions: Error while dumping state (probably corrupted stack)

So wie ich das sehe liegt das problem bei den Zuweisungen:

*fehlermeldung=".....";

Kann es daran liegen?

[Rika]

Ich sehe da eher gar nix, weil da sämtliche Symbole fehlen. Würdest du also mal Debug kompilieren?

Und nein, daran liegt es höchstens indirekt, wenn der Compiler für den String kein finales Literal erzeugt und nach Verlassen der Schleife den Speicher freiräumt.

Den Überlauf bei eingabe[i++] und die nicht eindeutige fgets()-Semantik hab ich ja auch schon benannt.

[cole-x]

hallo...

>> So wie ich das sehe liegt das problem bei den Zuweisungen:
>>
>> *fehlermeldung=".....";
>>
>> Kann es daran liegen?


so ist es. in C kann man Strings nicht so einfach zuweisen; dies muss (!) mittels strcpy (oder ähnlichem) erfolgen.
der Speicherplatz dafür muss VORHER angefordert werden (mit malloc(größe) z.B.) wobei darauf zu achten ist, das ein Byte MEHR als die maximale Stringlänge angefordert werden muss, da die Strings grundsätzlich mit einem Null-Byte enden.

also

*fehlermeldung = malloc(200); // 200 sollte eigentlich dafür mehr als ausreichend sein
strcpy(*fehlermeldung, "Alles i.O.");


wobei es aber sinnvoller wäre, fehlermeldung nicht als char ** sondern als char * zu deklarieren

int main(){

char *fehlermeldung;

fehlercode(&fehlermeldung);
printf("%s",fehlermeldung);

}

&fehlermeldung übergibt die Adresse der Variablen - bei char * wäre das der typ char **

btw: das es unter Linux funktioniert ist reiner Zufall

[Rika]

Zitat

so ist es. in C kann man Strings nicht so einfach zuweisen; dies muss (!) mittels strcpy (oder ähnlichem) erfolgen.
der Speicherplatz dafür muss VORHER angefordert werden (mit malloc(größe) z.B.) wobei darauf zu achten ist, das ein Byte MEHR als die maximale Stringlänge angefordert werden muss, da die Strings grundsätzlich mit einem Null-Byte enden.

Der String ist aber ein statisches Literal, für das auf dem Heap bereits Speicher reserviert wurde. Die Zuweisung bewirkt lediglich, daß *fehlermeldung ein Zeiger auf dieses Literal wird.

Die Verwendung von ** wird auch unmittlebar klar, da der String, nämlich das char[]-Array bzw. char* als Referenz übergeben werden soll.


Meine Befürchtung ist eher, daß char eingabe[300]; kein Speicher zugewiesen wird, aber fgets() darin schreibt - zumindest ist das die mir bekannte Semantik. Die Alternative, nämlich daß ein Pointer auf eine read-only-Sektion des Puffers von stdin übergeben wird, ist ja auch nicht plattformübergreifend realisierbar. char[300] jedenfalls erzeugt kein statisches Literal, sondern nur einen Zeiger char* mit der Typung char[300].

Oder halt der Overflow bei eingabe[i++], wenn die Ausgabe länger als 300 Zeichen ist und kein \n vorhanden ist.

[Witi]

Zitat

aber fgets() darin schreibt

hmm...das können wir doch einfach überprüfen.
Wozu hat fgets denn einen Rückgabewert...

 if( NULL == fgets(eingabe, sizeof(eingabe), stdin)) {
	printf("Fehler!");
	return;
}

[bb83]

So hab das ganze jetzt per strcpy() gemacht und vorher die Array Grösse festgelegt:
char fehlermeldung[200]
Das ganze spart mir nun auch den den zweiten Pointer, hat allerdings auch den Nachteil, das ich in der main char fehlermeldung [] schon deklarieren muss

Vielen Dank für eure Hilfe