Brauche dringend HILFE!!!

ja also dann erklär mal wo dein problem liegt, ich kanns dir sogar sagen du willst nicht sortieren...

SlotRacer

Doch wollen schon aber ehrlich gesagt hasb ich NULL Ahnung WIE!!!
Das ist mein Problem. Ich blättere schon die ganze Zeit in nem Buch und such im Netz, aber so richtig werd ich da nicht schlau drauß.

nachdem wir ein array genommen haben und keine liste funktioniert das ganz easy mit qsort

.-das array
      |         .-länge des arrays
qsort(dataCache,l,sizeof(struct vertrag),cmp);
                  '-größe eines array    '-vergleichs function ungefähr so int (*cmp)(void *,void *){}
                    eintrags

SlotRacer

Also deinen letzten Post hab ich noch nicht richtig verstanden.... Blicke isrgendwie nicht so richtig durch den ganzen wirrwar :-).

also ersmal brauchst du eine vergleichs function, welche qsort sagt ob a größer b oder anders herum, das schaut dann z.b. für die liefermege so aus

int compareLiefermenge(void *a,void *b){
	struct vertrag *ax = a;
	struct vertrag *bx = b;
	return ax->liefermenge-bx->liefermenge;
}

ich weiß das ist nicht 100% sicher da überlauf aber ok...

dann mußt du qsort füttern also so...

qsort(dataCache,dataCacheLength,sizeof(struct vertrag),compareLiefermenge);

versuch das doch mal in der main z.b. so

int main(void){
...
plotEntrys(dataCache,dataCacheLength);
qsort(dataCache,dataCacheLength,sizeof(struct vertrag),compareLiefermenge);
plotEntrys(dataCache,dataCacheLength);
...
}

int compareLiiferant(void *a,void *b){ 
    struct vertrag *ax = a; 
    struct vertrag *bx = b; 
    return strcmp (ax->liiferant,bx->liiferant);
}

:xmas1:

noobLolo schrieb:

also deinen letzten code hab ich ein bischen umgebaut, das ergebnis poste ich mal...

Ganz ohne Abbruchbedingung in readEntrys, tsts...
Ein bisschen unflexibel, findest du nicht? Wenn 1024 Verträge abgeschlossen sind, dann macht die Firma eventuell Verluste, weil plötzlich die Software streikt.
Bis zum 2048-Verträge-Release ist sie vielleicht schon bankrott.

noobLolo schrieb:

nachdem wir ein array genommen haben und keine liste...

sag bloss, hier hat wieder einer mit linked lists angefangen. und wenn ja, lass mich raten, wer's war... *fg*

SlotRacer

Hey ich hab heute keine Lust mehr. Werde mich morgen wieder melden....
Danke erstmal an euch alle hier. Ich hoffe ich kann morgen auch noch auf euch zählen.

MfG

Big Brother schrieb:

Ganz ohne Abbruchbedingung in readEntrys, tsts...

while(maxLength-- && fread(&dataCache[i], sizeof(struct vertrag),1, Dateiptr) == 1)
statt
while(fread(&dataCache[i], sizeof(struct vertrag),1, Dateiptr) == 1)

sollte es ein bischen besser machen, ja ich hatte schon daran gedacht aber ist dann in vergessenheit geraten

jetzt hab ich extra, und ums mir einfach zu machen ein array genommen und dann bekomm ich doch wieder einen auf die mütze

noobLolo schrieb:

jetzt hab ich extra, und ums mir einfach zu machen ein array genommen und dann bekomm ich doch wieder einen auf die mütze

:p

Najanun, selbst wenn du das abfängst - was ist, wenn 1024 Strukturen nicht mehr reichen?

;fricky schrieb:

noobLolo schrieb:

nachdem wir ein array genommen haben und keine liste...

sag bloss, hier hat wieder einer mit linked lists angefangen. und wenn ja, lass mich raten, wer's war... *fg*

Die Vermutung liegt nahe ...

unsigned short liefertermin[3]; 

// VERTRAG.DAT

// D     M     Y
// 13 00 04 00 5B 00

// -> 19.04.91

Y ist zweistellig!

fassungsloser schrieb:

Y ist zweistellig!

Vielleicht kommt der Prof aus der Cobol-Ecke?

Vielleicht ist es auch ein Format, wie es noobLolo bereits vermutet hat.
Im Grunde reicht ja ein

time_t liefertermin;

aus.

SlotRacer

Hallo Leute. Hab heut erfahren das ich die Aufgabe bis Donnerstag abzugeben hab. Kann mir bitte jemand sagen wie ich Aufgabe 2 und 3 hinbekomme???

Ich bitte euch Jungs und Mädels.....

Bin am verzweifeln.

also ich kenns ja nur so das man immer mehr zeit hat und nicht weniger aber jede schule ist da ja ein bischen anders also wo waren wir
aja beim sortieren wenn du mir die sortier function sagen kannst mit der du nach dem feld ->vertrnr sortieren kannst bekommst die restlichen umsonst, falls du nicht weißt wie das geht du hast 2 beispiele auf den letzten 1-2 seiten

- die Namen aller Lieferanten bei denen bis zu einem, vom Nutzer einzugebenden
Termin keine Abweichungen zwischen Vertrags- und Liefermenge auftraten.

also die aufgabe bin ich so angegangen...

void getEachEntrySmallerThanDate(struct vertrag dataCache[],int length){
	struct vertrag dateData;
	setSortModeAsc();
	sortBy(dataCache,length,compareLieferant);
	//plotEntrys(dataCache,length);
	readDate(&dateData);
	plotFooter();
	int i=0;
	while(i<length){
		if(compareDate(&dataCache[i++],&dateData)<0){
			if(compareLiefermengeVsVertragsmenge(&dataCache[i-1])){
				plotEntryRow(dataCache[i-1],i-1);
				//skip each entry with the same company name
				while(i<length-1 && compareLieferant(&dataCache[i-1],&dataCache[i])==0)
					i++;
			}
		}
	}
}

also wie auch immer ich poste jetzt mal meine version, kannst sie gerne kopieren, aber nützen wird es dir nicht viel... nunja das mußt du dann selbst entscheiden,
auch kommen da bei der ausgabe immer ne ganze menge � raus aber nunja das eher ein zeichensatzproblem evtl. muß man das decodieren und die printf() sind auch unsauber aber naja

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <curses.h>

/**
 * definitionen
 */
#define LOLO_HR "-------------------------------------------------------------"\
				"-------------------------------------------------------------"

/**
 * super globals
 */
int global_sortModeAscDesc;

/**
 * structures
 */
struct vertrag{
	char vertrnr[7];
	char art[21];
	char liiferant[21];
	unsigned short vertagsmenge;
	unsigned short liefertermin[3];
	unsigned short liefermenge;
}__attribute__((packed))vertrag;

void clearStdIn(){
	char buffer[1024];
	fgets(buffer,1024,stdin);
}

int getIntFromStdIn(){
	int cache;
	scanf("%ud",&cache);
	clearStdIn();
	return cache;
}

int getCharFromStdIn(){
	int ret = getchar();
	clearStdIn();
	return ret;
}

void initTerminalScreen(){
	//initscr();
}
void clearTerminalScreen(){
	//refresh();
#define LINUX
#ifdef LINUX
	system("clear");
#else
	system("cls");
#endif
}
void exitTerminalScreen(){
	//endwin();
}

void plotHeader(char *s){
	printf(
		" .-----------------------------------------------\n"
		" | %s |\n"
		LOLO_HR
		"\n",s
	);
}

void plotFooter(){
	printf(
		LOLO_HR
		"\n"
	);
}

void plotMenu(){
	printf(
		"\n"
		"\n .------------------------------------------------------.   .---------------."
		"\n |  Menue :: drücken sie die taste in den [ ] klammern  |   | [a]sc  [d]esc |"
		"\n |" LOLO_HR
		"\n | [p] plot table"
		"\n | [b] für alle Hauptlieferanten mit Vertragsmenge > 500"
		"\n | [x] alle Angaben zu Verträgen mit einem Lieferanten"
		"\n | [f] die Namen aller Lieferanten bei denen bis zu einem Termin keine"
		"\n |     Abweichungen zwischen Vertrags- und Liefermenge auftraten."
		"\n | [q] QUIT"
		"\n |" LOLO_HR
		"\n | Ihre Auswahl: "
	);
}

void setSortModeAsc(){
	global_sortModeAscDesc = 1;
}
void setSortModeDesc(){
	global_sortModeAscDesc = 0;
}

int extendedStringCmp(char *a,char *b){
	int len = strlen(a)-strlen(b);
	if(len==0){
		return strcmp(a,b);
	}
	return len;
}

int compareLiefermengeVsVertragsmenge(void *a){
	struct vertrag *ax = a;
	return ax->liefermenge-ax->vertagsmenge;
}
int compareLiefermenge(void *a,void *b){
	struct vertrag *ax = a;
	struct vertrag *bx = b;
	if(global_sortModeAscDesc)
		return ax->liefermenge-bx->liefermenge;
	else
		return -(ax->liefermenge-bx->liefermenge);
}
int compareVertragsmenge(void *a,void *b){
	struct vertrag *ax = a;
	struct vertrag *bx = b;
	if(global_sortModeAscDesc)
		return ax->vertagsmenge-bx->vertagsmenge;
	else
		return -(ax->vertagsmenge-bx->vertagsmenge);
}
int compareVertragsnummer(void *a,void *b){
	struct vertrag *ax = a;
	struct vertrag *bx = b;
	if(global_sortModeAscDesc)
		return extendedStringCmp(ax->vertrnr,bx->vertrnr);
	else
		return -extendedStringCmp(ax->vertrnr,bx->vertrnr);
}
int compareLieferant(void *a,void *b){
	struct vertrag *ax = a;
	struct vertrag *bx = b;
	if(global_sortModeAscDesc)
		return extendedStringCmp(ax->liiferant,bx->liiferant);
	else
		return -extendedStringCmp(ax->liiferant,bx->liiferant);
}
int compareArtikel(void *a,void *b){
	struct vertrag *ax = a;
	struct vertrag *bx = b;
	if(global_sortModeAscDesc)
		return extendedStringCmp(ax->art,bx->art);
	else
		return -extendedStringCmp(ax->art,bx->art);
}
int compareDate(void *a,void *b){
	struct vertrag *ax = a;
	struct vertrag *bx = b;
	int ret = 0;
	if(ax->liefertermin[2] > bx->liefertermin[2])
		ret = 1;
	if(ax->liefertermin[2] < bx->liefertermin[2])
		ret = -1;
	if(ax->liefertermin[1] > bx->liefertermin[1])
		ret = 1;
	if(ax->liefertermin[1] < bx->liefertermin[1])
		ret = -1;
	if(ax->liefertermin[0] > bx->liefertermin[0])
		ret = 1;
	if(ax->liefertermin[0] < bx->liefertermin[0])
		ret = -1;

	if(global_sortModeAscDesc)
		return ret;
	else
		return -ret;
}

void sortBy(struct vertrag dataCache[],int l,int (*cmp)(void *,void *)){
	qsort(dataCache,l,sizeof(struct vertrag),(__compar_fn_t)cmp);
}

int readEntrys(char *fileName,struct vertrag dataCache[],int maxLength){
	int i=0;
	FILE *Dateiptr = fopen(fileName,"rb");
	if(Dateiptr == NULL)
       printf("Beim oeffnen der Datei %s ist ein Fehler aufgetreten.\n", fileName);
    else
    	while(maxLength-- && fread(&dataCache[i], sizeof(struct vertrag),1, Dateiptr) == 1)
            i++;

	return i;
}

void plotEntryRow(struct vertrag dataCache,int i){
	printf(
		"%12d\t" "%7s\t" "%21s\t" "%21s\t" "%12d\t" "%12d\t" "%2d." "%2d." "%4d" "\n"
		,i
		,dataCache.vertrnr
		,dataCache.art
		,dataCache.liiferant
		,dataCache.vertagsmenge
		,dataCache.liefermenge
		,dataCache.liefertermin[0]
		,dataCache.liefertermin[1]
		,dataCache.liefertermin[2]
	);
}

void plotEntrys(struct vertrag dataCache[],int length){
	int i=0;
	printf(
		"%12s\t" "%7s\t" "%21s\t" "%21s\t" "%12s\t" "%12s\t" "%10s\t" "\n"
		LOLO_HR "\n"
		,"nr."
		,"[v]nr."
		,"a[r]tikel"
		,"l[i]eferant"
		,"v[e]rtragsm."
		,"[l]ieferm."
		,"l[t]ermin."
	);

	while(i<length){
		plotEntryRow(dataCache[i],i);
		i++;
	}
}

void readDate(struct vertrag *dataCache){
	int cache;

	do{
		printf("enter day   1-31: ");
		cache = getIntFromStdIn();
	}while(cache<1||cache>31);
	dataCache->liefertermin[0] = (unsigned short)cache;

	do{
		printf("enter month 1-12: ");
		cache = getIntFromStdIn();
	}while(cache<1||cache>12);
	dataCache->liefertermin[1] = (unsigned short)cache;

	do{
		printf("enter year  1-99: ");
		cache = getIntFromStdIn();
	}while(cache<1||cache>99);
	dataCache->liefertermin[2] = (unsigned short)cache;
}

void getEachEntrySmallerThanDate(struct vertrag dataCache[],int length){
	struct vertrag dateData;
	setSortModeAsc();
	sortBy(dataCache,length,compareLieferant);
	//plotEntrys(dataCache,length);
	readDate(&dateData);
	plotFooter();
	int i=0;
	while(i<length){
		if(compareDate(&dataCache[i++],&dateData)<0){
			if(compareLiefermengeVsVertragsmenge(&dataCache[i-1])){
				plotEntryRow(dataCache[i-1],i-1);
				//skip each entry with the same company name
				while(i<length-1 && compareLieferant(&dataCache[i-1],&dataCache[i])==0)
					i++;
			}
		}
	}
}

void getEachBigOne(struct vertrag dataCache[],int length){
	setSortModeAsc();
	sortBy(dataCache,length,compareLieferant);
	int i=0;
	while(i<length){
		if(dataCache[i++].vertagsmenge > 500){
			plotEntryRow(dataCache[i-1],i-1);
			//skip each entry with the same company name
			while(i<length-1 && compareLieferant(&dataCache[i-1],&dataCache[i])==0)
				i++;
		}
	}
}

void getListOf(struct vertrag dataCache[],int length){
	setSortModeAsc();
	sortBy(dataCache,length,compareLieferant);
	int i=0;
	int number=0;
	while(i<length){
		//plotEntryRow(&dataCache[i-1]);
		printf("%7d\t%s\n",i,dataCache[i].liiferant);
		while(i<length-1 && compareLieferant(&dataCache[i],&dataCache[i+1])==0)i++;
		i++;
	}
	plotFooter();
	printf(" enter number: ");
	number = getIntFromStdIn();
	struct vertrag nameData;
	nameData.liefermenge = 0;
	nameData.vertagsmenge = 0;
	memcpy(nameData.liiferant,dataCache[number].liiferant,sizeof(nameData.liiferant));
	clearTerminalScreen();
	plotHeader(nameData.liiferant);
	sortBy(dataCache,length,compareArtikel);
	i=0;
	int flag=0;
	while(i<length){
		if(compareLieferant(&nameData,&dataCache[i])==0){
			while(i<length-1 && compareArtikel(&dataCache[i],&dataCache[i+1])==0){
				if(flag==0){
					strcpy(nameData.art,dataCache[i].art);
					strcpy(nameData.liiferant,dataCache[i].liiferant);
					strcpy(nameData.vertrnr,dataCache[i].vertrnr);
					nameData.liefertermin[0] = 0;
					nameData.liefertermin[1] = 0;
					nameData.liefertermin[2] = 0;
				}
				nameData.liefermenge+=dataCache[i].liefermenge;
				nameData.vertagsmenge+=dataCache[i].vertagsmenge;
				flag=1;
				i++;
			}
			if(flag){
				i--;
				flag=0;
				nameData.liefermenge+=dataCache[i].liefermenge;
				nameData.vertagsmenge+=dataCache[i].vertagsmenge;
				plotEntryRow(nameData,0);
				i++;
			}else
				plotEntryRow(dataCache[i],i);
		}
		i++;
	}
}

int getFileSize(char *fileName){
	FILE *fp = fopen(fileName,"rb");
	if(fp==NULL){
       printf("Beim oeffnen der Datei %s ist ein Fehler aufgetreten.\n", fileName);
       return -1;
    }
	return fseek(fp,0,SEEK_END)?-1:ftell(fp);
}

void *getArrayForFile(char *fileName,int *bufferSize,int typeSize){
	int sizeCache = getFileSize(fileName);
	if(sizeCache==-1)
		return NULL;
	*bufferSize = sizeCache/typeSize;
	return malloc(sizeCache);
}

int main(int argc, char *argv[]){
	initTerminalScreen();
	int dataCacheLength;
	char *fileName = "/home/matthias/Desktop/VERTRAG.DAT";
    struct vertrag *dataCache;
    dataCache = getArrayForFile(fileName,&dataCacheLength,sizeof(struct vertrag));
    dataCacheLength = readEntrys(fileName,dataCache,1024);
    int (*activeSort)(void *,void *) = compareVertragsnummer;

    while(1){
LABEL_SKIP_PLOT:
		plotMenu();
    	switch(getCharFromStdIn()){
    		case 'p':
	    	case 'P':
	    		setSortModeAsc();
	    	goto LABEL_SORT_TABLE;
    		case 'a':
	    	case 'A':
	    		setSortModeAsc();
	    	goto LABEL_SORT_TABLE;
	    	case 'd':
	    	case 'D':
	    		setSortModeDesc();
    		goto LABEL_SORT_TABLE;
	    	case 'r':
	    	case 'R':
	    		activeSort = compareArtikel;
    		goto LABEL_SORT_TABLE;
	    	case 'l':
	    	case 'L':
	    		activeSort = compareLiefermenge;
    		goto LABEL_SORT_TABLE;
	    	case 'e':
	    	case 'E':
	    		activeSort = compareVertragsmenge;
    		goto LABEL_SORT_TABLE;
	    	case 'v':
	    	case 'V':
	    		activeSort = compareVertragsnummer;
    		goto LABEL_SORT_TABLE;
	    	case 'i':
	    	case 'I':
	    		activeSort = compareLieferant;
    		goto LABEL_SORT_TABLE;
	    	case 't':
	    	case 'T':
    			activeSort = compareDate;
			goto LABEL_SORT_TABLE;
	    	case 'f':
	    	case 'F':
	    		clearTerminalScreen();
	    		plotHeader("die Namen aller Lieferanten bei denen bis zu einem Termin keine ...");
	    		getEachEntrySmallerThanDate(dataCache,dataCacheLength);
	    		plotFooter();
    		goto LABEL_SKIP_PLOT;
	    	case 'b':
	    	case 'B':
	    		clearTerminalScreen();
	    		plotHeader("alle Hauptlieferanten mit Vertragsmenge > 500");
	    		getEachBigOne(dataCache,dataCacheLength);
	    		plotFooter();
    		goto LABEL_SKIP_PLOT;
	    	case 'x':
	    	case 'X':
	    		clearTerminalScreen();
	    		plotHeader("alle Angaben zu Verträgen mit einem Lieferanten");
	    		getListOf(dataCache,dataCacheLength);
	    		plotFooter();
    		goto LABEL_SKIP_PLOT;
	    	case 'q':
	    	case 'Q':
    		goto LABEL_QUIT_APP;
    	}
LABEL_SORT_TABLE:
    	clearTerminalScreen();
		sortBy(dataCache,dataCacheLength,activeSort);
		plotEntrys(dataCache,dataCacheLength);
    }
LABEL_QUIT_APP:
	exitTerminalScreen();
    return 0;
};

na dann mal viel spaß damit

Du verlässt dich ganz schön blind darauf, das die Standardfunktionen fruchten. Die Anzahl der Strukturen ist immer noch hartcodiert, aber das soll wohl nur ne Demo sein, ne