2Dimensionales Array in Struct dynamisch vergrößern und an Funktion übergeben

xpulse

Hallo erstmal!

Ich habe folgendes Problem...
Ich sollte für die Uni ein Programm schreiben dass eine Datei einließt die aus 0 und 1 besteht (eine bitmask für eine "font-datei") (die datei hat in der ersten zeile # 25 (der wert gibt die höhe an, und dann nur mehr 0en und 1en)

ich muss ein struct erstellen welches dann aus 95teilen besteht (für jeden buchstaben)
und in dem sollte ein 2 dimensionales array stehen, welches die höhe sowie breite 25 hat. diese zahl darf ich aber nicht beim initialisieren des arrays verwenden da ich diesen wert erst aus der ersten zeile der font datei lese.

danach muss ich das struct einer funktion übergeben, die dieses array befüllen sollte.

außerdem müssen die funktionen vor der main deklariert werden...

und ich hab folgende probleme:
1. weiß ich nicht wie ich das array 2 dimensional, dynamisch erstellen kann im struct
2. weiß ich nicht wie ich dieses struct dann übergeben muss bzw, wie ichs bei dem prototyp definieren soll...

anbei noch der code, da ichs nicht wirklich schaffe mein problem gut zu beschreiben

danke voraus für die hilfe
ich weiß einfach nicht mehr weiter

#include "stdio.h"
#include "math.h"
#include "stdlib.h"
#include "string.h"

#define LET_NUMB 95

#define ERR_TO_MUCH_ARGUMENTS -1
#define ERR_FONT_FILE_NOT_FOUND -2
#define ERR_FONT_FILE_CORRUPTED -3
#define ERR_INVALID_CHARACTERS -4
#define ERR_OUT_OF_MEMORY -5

#define STATE_OK 0

#define N 10                //newline
#define SP 32               //space
#define T 9                 //tab
#define R 13                //carriage return

typedef struct{
	char letter; //for symbols[0]=" ", for symbols[1]="!"
	int *array; //should be 2-dim. (saves the array of 0s and 1s)
}type_letter;

int errorhandler(int);
int readHeight(char*,int*);
int readFontFile(char*,int,type_letter*);
int power(int, int);
int charToInt(char);

int main(int argc, char * argv[] )
{
	type_letter symbols[LET_NUMB];
    int errorcode=STATE_OK;
    int height=0;
	int grow;
	if(argv[2]){
           errorcode=ERR_TO_MUCH_ARGUMENTS;
    }
    errorcode=readHeight(argv[1], &height);
	/*********************/
	/*for(grow=0;grow<LET_NUMB;grow++){
		symbols[grow].array=(int*)malloc(1*sizeof(int));
		if(symbols[grow].array==NULL){
			errorcode=ERR_OUT_OF_MEMORY;
			return errorcode;
		}
	}
	if(errorcode!=ERR_OUT_OF_MEMORY){
		errorcode=readFontFile(argv[1],height, symbols);
	}*/
	/**********************/

	errorcode=readFontFile(argv[1],height, symbols);
	errorhandler(errorcode);
	printf("\n");
    return STATE_OK;
}

int readFontFile(char* filename, int height, type_letter *symbols){
	FILE *file;
	char ch;
	int row=0;
	int col=0;
	int symb_cnt=0;
	int errorcode=0;
	if((file=fopen(filename,"r"))==0){
        return ERR_FONT_FILE_NOT_FOUND;
    }else{ 
		while((ch=fgetc(file))!='\n'){
			//JUST REMOVE THE FIRST LINE
        }
		while(row!=height){
			while(symb_cnt!=LET_NUMB){
				while(col!=(height-1)){
					ch=fgetc(file);
					switch(ch){
						case '1':   
									//symbols[symb_cnt].array[row][col]=1;
									// <-- so sollten die 0en und 1en dann gespeichert werden
									col++;
									break;
						case '0':   //symbols[symb_cnt].array[row][col]=0;
									col++;
									break;
						case SP:	break;
						case N:	break;
						case T:	break;
						case R:	break;
						default : errorcode=ERR_FONT_FILE_CORRUPTED;
					}

					//symbols.array[symb_cnt][row][col]=ch;
				}
				col=0;
				symb_cnt++;
			}
			ch=fgetc(file); //REMOVE THE LAST "1" (it's:(h-1)*95+1 per row and we have: (h-1)*95)
			symb_cnt=0;
			row++;
		}
	}
	return errorcode;
}

int readHeight(char* filename, int *height){
    FILE *file;
    int length = 0;;
    int exponent;
    char read_h[10];
    char ch;
	int tmp;
	int cnt=1;
    if((file=fopen(filename,"r"))==0){
        return ERR_FONT_FILE_NOT_FOUND;
    }else{  
        while((ch=fgetc(file))!='\n' && ch!=EOF ){
            read_h[length]=ch;
            length++;
        }
        read_h[length]='\n';
        exponent=length-2;
        for(;exponent>0;exponent--){

			tmp=charToInt(read_h[length-1]);
			//((int)read_h[length-1]-48);
            *height=*height+power(tmp,cnt);
			length--;
			cnt++;
		}
	    fclose(file);
        return STATE_OK;
  }
}
int errorhandler(int code){
    if(code!=STATE_OK){
                printf("\nERROR\n");
                return code;
    }
    else{return STATE_OK;}    
}
int power(int number, int exponent){
	int tmp=0;
	if(exponent==1){tmp=number;}
	while(exponent!=1){
		tmp=tmp+(number*10);
		exponent--;
	}
    return tmp;
}
int charToInt(char character){
	int tmp;
	tmp=(int)character-48;
	return tmp;
}

Th

Das auskommentierte malloc() ist schon fast richtig. Du mußt nur gleich für das gesamte Array den Speicher reservieren lassen, anschließend kannst du dann darauf als ein 1-dimensionales Array zugreifen.

symbols[grow].array=(int*)malloc(height*height*sizeof(int));

symbols[grow].array[x] = ...

Für Zugriff als 2-dimensionales Array mußt du selbst die Indizes richtig berechnen:

symbols[grow].array[row*height+col] = ...

wobei row und col jeweils den Wertebereich [0, height-1] haben.

2-dimensionale Arrays kann man in C nur zur Compilezeit erstellen.

crocus_sativus

Hallo!
Ich möchte ehrlich mittlerweile gar nicht wissen, wieviel Leute deinen Code jetzt abgeschrieben bzw. auch verwendet haben; denn mit diesem Problem warst du sicher nicht der einzige; und bei richtiger Suche findet man den Thread bei Google an 2. Stelle gepinnt.

Viel Erfolg bei den Punkten, weil bei Plagiat fliegen beide

allerdings... wie kommt man auf so ne idee>< und postet seinen code in nem forum ..

w1s2x3w

haha lol

also da muss ich guguga echt recht geben!