c++ - Allokere structures og pointers - Udvikleren.dk - Programmering, webdesign og grafik

Tags: c++

<< < 1 2 > >>

Bruger #14645 @ 11.06.10 17:33

Jeg er i gang med at lave et mini bibliotek til at læse bmp filer med i C. Jeg har 2 problemer. Den ene er hvordan allokerer jeg en structure ved brug af malloc/calloc uden at bruge explicit casting som nævnes bør undgås her: http://en.wikipedia.org/wiki/Calloc#Casting_and_type_safety
Den anden er at nogle af mine pointers på mystisk vis peger på NULL.

Min kode er som følger:

Kode

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

struct bmp_magic {
	unsigned char* magic[2];
};

struct bmp_header {
	uint32_t header_size;
	uint32_t width;
	uint32_t height;
	uint16_t color_planes;
	uint16_t bpp;
	uint32_t compress_type;
	uint32_t image_size;
	uint32_t hres;
	uint32_t vres;
	uint32_t colors;
	uint32_t important_colors;
};

struct bmp_file {
	struct bmp_magic* magic;
	struct bmp_header* header;
	uint8_t* data;
};

struct bmp_magic* bmp_readMagic(FILE* pfile) {
	struct bmp_magic* pMagic = (struct bmp_magic*)calloc(1, sizeof(struct bmp_magic));
	if (pMagic == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		fread(pMagic->magic, sizeof(unsigned char), 2, pfile);
	};
	return pMagic;
};

struct bmp_header* bmp_readHeader(FILE* pfile) {
	struct bmp_header* pHeader = (struct bmp_header*)calloc(1, sizeof(struct bmp_header));
	if (pHeader == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		size_t word = sizeof(uint16_t);
		size_t dword = sizeof(uint32_t);

		fread(&pHeader->header_size, dword, 1, pfile);
		fread(&pHeader->width, dword, 1, pfile);
		fread(&pHeader->height, dword, 1, pfile);
		fread(&pHeader->color_planes, word, 1, pfile);
		fread(&pHeader->bpp, word, 1, pfile);
		fread(&pHeader->compress_type, dword, 1, pfile);
		fread(&pHeader->image_size, dword, 1, pfile);
		fread(&pHeader->hres, dword, 1, pfile);
		fread(&pHeader->vres, dword, 1, pfile);
		fread(&pHeader->colors, dword, 1, pfile);
		fread(&pHeader->important_colors, dword, 1, pfile);
	};
	return pHeader;
};

struct bmp_file* bmp_readFile(FILE* pfile) {
	uint8_t* data;
	size_t dataSize;
	struct bmp_file* file = (struct bmp_file*)calloc(1, sizeof(struct bmp_file));

	if (file == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		file->magic = bmp_readMagic(pfile);
		file->header = bmp_readHeader(pfile);
		dataSize = file->header->image_size*sizeof(uint8_t);
		data = (uint8_t*)calloc(1, dataSize);
		fread(data, dataSize, 1, pfile);
		file->data = data;
	};
	return file;
};

void bmp_freeFile(struct bmp_file* file) {
	free(file->magic); file->magic = NULL;
	free(file->header); file->header = NULL;
	free(file->data); file->data = NULL;
};

int main(char* argv[], int argc) {
	struct bmp_file* bmpfile;
	FILE* pfile = fopen("C:\\test.bmp", "r");
	char dummy;

	bmpfile = bmp_readFile(pfile);
	if (bmpfile != NULL) {
		bmp_freeFile(bmpfile);
	}
	else
	{
		fprintf(stderr, "Could not read bmp file!\n");
	};
	fclose(pfile); pfile = NULL;

	printf("Value is: %s\n", bmpfile->magic); //GIVER NULL :S
	printf("Press enter to exit!\n");
	scanf("%c", &dummy);

	return 0;
};

Der er et billede det pågældende sted og jeg kan se at i f.eks. selve magic strukturen bliver magic sat til noget gyldigt tekst og tror at det er ved bmp_readFile at pointeren til denne struktur ikke bliver sat ordentligt. Jeg får ingen af de fejlbeskeder der er mulige så jeg lidt på bar bund.

På forhånd tak for hjælpen.

Bruger #4996 @ 11.06.10 19:24

196

Hvis du skriver rigtigt C kode (dvs. ikke C++) er der ingen grund til at have de der cast, nogen vil endda sige at de gør mere skade en gavn.

Hvis du skriver C++ kode, og af en eller anden grund vil bruge malloc/calloc er du nødt til at leve med de der cast.

Husk at når du har en pointer inden i en struct, skal du allokere hukommelse til denne pointer separat.

I øvrigt tror jeg at bmp_magic skal være to chars, ikke to pointer til char.

Der findes en struct der svarer til din bmp_header, som kan læses med én fread.

Bruger #14645 @ 11.06.10 20:35

806

Hvis du skriver rigtigt C kode (dvs. ikke C++) er der ingen grund til at have de der cast, nogen vil endda sige at de gør mere skade en gavn.

Hvis jeg fjerner casting får jeg: Error: a value of type "void *" cannot be used to initialize an entity of type "STRUCTURENAVN *"

Husk at når du har en pointer inden i en struct, skal du allokere hukommelse til denne pointer separat.

Hvordan skal det forstås. Jeg har prøvet at ændre min bmp_readFile() funktion til dette og det løser ikke problemet (altså lave pointeren med calloc):

Kode

struct bmp_file* bmp_readFile(FILE* pfile) {
	uint8_t* data;
	size_t dataSize;
	struct bmp_file* file = (struct bmp_file*)calloc(1, sizeof(struct bmp_file));
	struct bmp_magic* pMagic = (struct bmp_magic*)calloc(1, sizeof(struct bmp_magic*));
	struct bmp_header* pHeader= (struct bmp_header*)calloc(1, sizeof(struct bmp_header*));

	if (file == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		pMagic = bmp_readMagic(pfile);
		pHeader = bmp_readHeader(pfile);
		file->magic = pMagic;
		file->header = pHeader;
		dataSize = file->header->image_size*sizeof(uint8_t);
		data = (uint8_t*)calloc(1, dataSize);
		fread(data, dataSize, 1, pfile);
		file->data = data;
	};
	return file;
};

Der findes en struct der svarer til din bmp_header, som kan læses med én fread.

Du mener at jeg kunne læse de antal bytes min header struktur fylder ind som en header og så vil det være korrekt så længe min strukturs elementer har den korrekte rækkefølge? Men der er jo det problem at compileren laver om på rækkefølgen/størrelsen?

Indlæg senest redigeret d. 11.06.2010 20:37 af Bruger #14645

Bruger #4996 @ 11.06.10 20:54

196

Den første fejl tyder på at du oversætter det som C++ og ikke som C

Du skal
struct bmp_magic* pMagic = (struct bmp_magic*)calloc(1, sizeof(struct bmp_magic));
pMagic->magic[0] = calloc(1, 1234);
pMagic->magic[1] = calloc(1, 4321);
Husk også at free de to pointere inde i pMagic

Men som nævnt skal du lave strukturen om, til:
struct bmp_magic {
unsigned char magic[2];
};

OG så skal du kun have en malloc/calloc

Bruger #14645 @ 11.06.10 22:29

806

Jeg har nu næsten fået det hele til at virke. Jeg fjernede explicit casting og fik dermed rød tekst under. Men den kunne godt compile alligevel. Har et problem med magic strengen og data. Når jeg læser noget selv hvis jeg læser 0 bytes så bliver tekststrengen "ýýýý««««««««îþîþ" sat på til sidst. Jeg ved ikke hvorfor dette sker. Der er også problem med at free magic strengen men jeg det hænger sammen med den ekstra streng måske.

Kode

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define __FREE_NOT_NULL(variable) if (variable != NULL) free(variable);

struct bmp_magic {
	unsigned char magic[2];
};

struct bmp_header {
	uint32_t file_size;
	uint16_t reserved1;
	uint16_t reserved2;
	uint32_t offset;
};

struct dib_header {
	uint32_t header_size;
	uint32_t width;
	uint32_t height;
	uint16_t color_planes;
	uint16_t bpp;
	uint32_t compress_type;
	uint32_t image_size;
	uint32_t hres;
	uint32_t vres;
	uint32_t colors;
	uint32_t important_colors;
};

struct bmp_file {
	struct bmp_magic* magic;
	struct bmp_header* bmpHeader;
	struct dib_header* dibHeader;
	uint8_t* data;
};

struct bmp_magic* bmp_readMagic(FILE* pfile) {
	struct bmp_magic* pMagic = calloc(1, sizeof(struct bmp_magic));
	if (pMagic == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		*pMagic->magic = calloc(2, sizeof(unsigned char));
		fread(pMagic->magic, sizeof(unsigned char), 2, pfile);
	};
	printf("Value is: %c%c\n", pMagic->magic[0], pMagic->magic[1]); //GIVER BM restfyld indtil \0
	return pMagic;
};

struct bmp_header* bmp_readBmpHeader(FILE* pfile) {
	struct bmp_header* pHeader = calloc(1, sizeof(struct bmp_header));
	if (pHeader == NULL) {
		fprintf(stderr, "Error allocation memory!\n");
	}
	else
	{
		size_t word = sizeof(uint16_t);
		size_t dword = sizeof(uint32_t);
		fread(&pHeader->file_size,			dword, 1, pfile);
		fread(&pHeader->reserved1,			 word, 1, pfile);
		fread(&pHeader->reserved2,			 word, 1, pfile);
		fread(&pHeader->offset,				dword, 1, pfile);
	};
	return pHeader;
};

struct dib_header* bmp_readDibHeader(FILE* pfile) {
	struct dib_header* pHeader = calloc(1, sizeof(struct dib_header));
	if (pHeader == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		size_t word = sizeof(uint16_t);
		size_t dword = sizeof(uint32_t);

		fread(&pHeader->header_size,		dword, 1, pfile);
		fread(&pHeader->width,				dword, 1, pfile);
		fread(&pHeader->height,				dword, 1, pfile);
		fread(&pHeader->color_planes,		 word, 1, pfile);
		fread(&pHeader->bpp,				 word, 1, pfile);
		fread(&pHeader->compress_type,		dword, 1, pfile);
		fread(&pHeader->image_size,			dword, 1, pfile);
		fread(&pHeader->hres,				dword, 1, pfile);
		fread(&pHeader->vres,				dword, 1, pfile);
		fread(&pHeader->colors,				dword, 1, pfile);
		fread(&pHeader->important_colors,	dword, 1, pfile);
	};
	return pHeader;
};

struct bmp_file* bmp_readFile(FILE* pfile) {
	uint8_t* data;
	size_t dataSize;
	struct bmp_file* file = calloc(1, sizeof(struct bmp_file));

	if (file == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		file->magic = bmp_readMagic(pfile);
		file->bmpHeader = bmp_readBmpHeader(pfile);
		file->dibHeader = bmp_readDibHeader(pfile);
		dataSize = 0; //(file->dibHeader->image_size * sizeof(uint8_t)) - (file->bmpHeader->offset * sizeof(uint8_t));
		data = calloc(1, dataSize);
		fread(data, dataSize, 1, pfile);
		file->data = data;
	};
	return file;
};

void bmp_freeFile(struct bmp_file* file) {
	//__FREE_NOT_NULL(file->magic->magic);
	__FREE_NOT_NULL(file->magic);
	__FREE_NOT_NULL(file->bmpHeader);
	__FREE_NOT_NULL(file->dibHeader);
	__FREE_NOT_NULL(file->data);
	__FREE_NOT_NULL(file);
};

int main(char* argv[], int argc) {
	struct bmp_file* bmpfile;
	FILE* pfile = fopen("C:\\test.bmp", "r");
	char dummy;

	bmpfile = bmp_readFile(pfile);
	if (bmpfile == NULL) {
		fprintf(stderr, "Could not read bmp file!\n");
	}
	else
	{
			printf("Value is: %c%c\n", bmpfile->magic->magic[0], bmpfile->magic->magic[1]);
			printf("Press enter to exit!\n");
			scanf("%c", &dummy);
			bmp_freeFile(bmpfile); bmpfile = NULL;
	};
	fclose(pfile); pfile = NULL;
	return 0;
};

Bruger #4996 @ 12.06.10 00:56

196

Du skal ikke have denne linje:
*pMagic->magic = calloc(2, sizeof(unsigned char));

Men ellers læser den magic til BM som den skal, jeg har ikke checket om resten virker.

Bruger #14645 @ 12.06.10 02:42

806

Du skal ikke have denne linje:
*pMagic->magic = calloc(2, sizeof(unsigned char));

Nej kan jeg godt se nu, jeg laver jo en hel struktur alligevel så dette element er jo helt nyt.

Tror jeg har løst problemet/årsagen. Debuggeren ignorerer de størrelsesbegrænsninger der er på variablerne. F.eks. magic strengen på en BMP er typisk "BM" den ignorerer så begrænsningen i at den kun må være 2 elementer og læser videre i hukommelsen indtil den tilfældigt rammer et '\0'. Jeg prøve de at forlænge størrelsen af arrayet med én og sætte den sidste til '\0' og så stoppede de tilfældige tegn der kommer bagved i debuggeren.

Mange tak for hjælpen Bertel

Bruger #14645 @ 12.06.10 11:07

806

Kom til at "svare" i nedenstående.

Indlæg senest redigeret d. 12.06.2010 17:50 af Bruger #14645

Bruger #14645 @ 12.06.10 17:38

806

Hmm er lidt bekymret over at hukommelsen ikke bliver frigjort.

Har en macro:

Kode

#define __FREE_NOT_NULL(variable) if (variable != NULL) free(variable);

bmp_file er en struktur med allokerede pointere:

Kode

struct bmp_file {
	struct bmp_magic* magic;
	struct bmp_header* bmpHeader;
	struct dib_header* dibHeader;
	uint8_t* data;
};

Jeg frigører sådan en struktur med:

Kode

void bmp_freeFile(struct bmp_file* file) {
	__FREE_NOT_NULL(file->magic);
	__FREE_NOT_NULL(file->bmpHeader);
	__FREE_NOT_NULL(file->dibHeader);
	__FREE_NOT_NULL(file->data);
	__FREE_NOT_NULL(file);
};

Jeg har denne her main hvor jeg laver 5000 af disse strukturer:

Kode

int main(int argc, char** argv) {
    int n = 5000;
    int i=0;

    struct bmp_file* bmpfiles[n];
	char dummy;
    FILE* pfile = fopen("C:\\test.bmp", "r");

    printf("Before allocating\n");
    scanf("%c", &dummy);

    for(i=0; i<n; i++) {
        rewind(pfile);
        bmpfiles[i] = bmp_readFile(pfile);
    };

	fclose(pfile); pfile = NULL;

    printf("Before freeing\n");
    scanf("%c", &dummy);
    for (i=0; i<n; i++) {
        bmp_freeFile(bmpfiles[i]);
        bmpfiles[i] = NULL;
    };
    printf("After freeing\n");
    printf("Press enter to exit!\n");
    scanf("%c", &dummy);
	return 0;
};

Før den har allokeret alle n strukturer bruger programmet:
Ved n=100
Start: 348KB
Efter allokering: 1256KB
Efter frigørelse: 1256KB

Ved n=500
Start: 348KB
Efter allokering: 4104KB
Efter frigørelse: 2460KB

Ved n=1000
Start: 352KB
Efter allokering: 7704KB
Efter frigørelse: 2484KB

Ved n=5000
Start: 372KB
Efter allokering: 35576KB
Efter frigørelse: 4412KB

Hvorfor kan det være at den svinger sådan?? Og alle tallene kan svinge med et par kilobytes forskellig ved hver kørsel?

Her er hele koden hvis den ønskes set:

Kode

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define __FREE_NOT_NULL(variable) if (variable != NULL) free(variable);

struct bmp_magic {
	unsigned char magic[2];
};

struct bmp_header {
	uint32_t file_size;
	uint16_t reserved1;
	uint16_t reserved2;
	uint32_t offset;
};

struct dib_header {
	uint32_t header_size;
	uint32_t width;
	uint32_t height;
	uint16_t color_planes;
	uint16_t bpp;
	uint32_t compress_type;
	uint32_t image_size;
	uint32_t hres;
	uint32_t vres;
	uint32_t colors;
	uint32_t important_colors;
};

struct bmp_file {
	struct bmp_magic* magic;
	struct bmp_header* bmpHeader;
	struct dib_header* dibHeader;
	uint8_t* data;
};

struct bmp_magic* bmp_readMagic(FILE* pfile) {
	struct bmp_magic* pMagic = calloc(1, sizeof(struct bmp_magic));
	if (pMagic == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		fread(pMagic->magic, sizeof(unsigned char), 2, pfile);
	};
	return pMagic;
};

struct bmp_header* bmp_readBmpHeader(FILE* pfile) {
	struct bmp_header* pHeader = calloc(1, sizeof(struct bmp_header));
	if (pHeader == NULL) {
		fprintf(stderr, "Error allocation memory!\n");
	}
	else
	{
		size_t word = sizeof(uint16_t);
		size_t dword = sizeof(uint32_t);
		fread(&pHeader->file_size,			dword, 1, pfile);
		fread(&pHeader->reserved1,			 word, 1, pfile);
		fread(&pHeader->reserved2,			 word, 1, pfile);
		fread(&pHeader->offset,				dword, 1, pfile);
	};
	return pHeader;
};

struct dib_header* bmp_readDibHeader(FILE* pfile) {
	struct dib_header* pHeader = calloc(1, sizeof(struct dib_header));
	if (pHeader == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		size_t word = sizeof(uint16_t);
		size_t dword = sizeof(uint32_t);

		fread(&pHeader->header_size,		dword, 1, pfile);
		fread(&pHeader->width,				dword, 1, pfile);
		fread(&pHeader->height,				dword, 1, pfile);
		fread(&pHeader->color_planes,		 word, 1, pfile);
		fread(&pHeader->bpp,				 word, 1, pfile);
		fread(&pHeader->compress_type,		dword, 1, pfile);
		fread(&pHeader->image_size,			dword, 1, pfile);
		fread(&pHeader->hres,				dword, 1, pfile);
		fread(&pHeader->vres,				dword, 1, pfile);
		fread(&pHeader->colors,				dword, 1, pfile);
		fread(&pHeader->important_colors,	dword, 1, pfile);
	};
	return pHeader;
};

struct bmp_file* bmp_readFile(FILE* pfile) {
	uint8_t* data;
	size_t dataSize;
	struct bmp_file* file = calloc(1, sizeof(struct bmp_file));

	if (file == NULL) {
		fprintf(stderr, "Error allocating memory!\n");
	}
	else
	{
		file->magic = bmp_readMagic(pfile);
		file->bmpHeader = bmp_readBmpHeader(pfile);
		file->dibHeader = bmp_readDibHeader(pfile);
		dataSize = file->dibHeader->image_size*sizeof(uint8_t);
		data = calloc(1, dataSize);
		fread(data, dataSize, 1, pfile);
		file->data = data;
	};
	return file;
};

void bmp_freeFile(struct bmp_file* file) {
	__FREE_NOT_NULL(file->magic);
	__FREE_NOT_NULL(file->bmpHeader);
	__FREE_NOT_NULL(file->dibHeader);
	__FREE_NOT_NULL(file->data);
	__FREE_NOT_NULL(file);
};

int main(int argc, char** argv) {
    int n = 5000;
    int i=0;

    struct bmp_file* bmpfiles[n];
	char dummy;
    FILE* pfile = fopen("C:\\test.bmp", "r");

    printf("Before allocating\n");
    scanf("%c", &dummy);

    for(i=0; i<n; i++) {
        rewind(pfile);
        bmpfiles[i] = bmp_readFile(pfile);
    };

	fclose(pfile); pfile = NULL;

    printf("Before freeing\n");
    scanf("%c", &dummy);
    for (i=0; i<n; i++) {
        bmp_freeFile(bmpfiles[i]);
        bmpfiles[i] = NULL;
    };
    printf("After freeing\n");
    printf("Press enter to exit!\n");
    scanf("%c", &dummy);
	return 0;
};

Indlæg senest redigeret d. 12.06.2010 17:47 af Bruger #14645

Bruger #4996 @ 12.06.10 23:51

196

Jeg kan ikke se at der er noget galt med koden. Hvordan har du fundet de tal for hukommelsesforbrug? Du kan ikke være sikker på at programmet giver hukommelsen tilbage til OS'et med det samme. I "gamle" DOS dage gav et program aldrig hukommelse tilbage til DOS, når det først havde fået den.

Lige et par bemærkninger:
1: Der er ingen grund til at bruge din macro __FREE_NOT_NULL, free checker selv om pointeren er NULL.

2: Man har normalt ikke ; efter den sidste } i funktioner, de virker forvirrende.

3: sizeof(char), sizeof(uint8_t) og sizeof(unsigned char) er altid 1.

Bruger #14645 @ 13.06.10 12:50

806

Jeg kan ikke se at der er noget galt med koden. Hvordan har du fundet de tal for hukommelsesforbrug? Du kan ikke være sikker på at programmet giver hukommelsen tilbage til OS'et med det samme. I "gamle" DOS dage gav et program aldrig hukommelse tilbage til DOS, når det først havde fået den.

Jeg bruger joblisten i windows (taskmgr.exe). Virker da bare lidt pudsigt at det altid er det samme som der er til overs. Er C ikke så low level at hvis jeg siger frigør så når det kald ned til OS'et som så frigører hukommelsen? Der vel ingen garbage collector at tage i betragtning

.

Så vil du tro at programmet fungerer korrekt (til den grad man kan være sikker)?

<< < 1 2 > >>

Allokere structures og pointers

Karma barometer (30 dage)

Modtaget

Givet

Favorit hos
Forum tråde
Artikler