Dynamisches Array vergößern und initialisieren

nico.prenzel

Hallo Forum,

ich habe folgendes Problem und bin mir sicher, dass ich nicht weit von der Lösung entfernt bin. Aber ich komm i.M. nicht drauf.

Habe einen eigenen Datentyp definiert:

typedef struct
{
  char   *strRecipientAddress;
  char   *strTests;         

}   RecipientInfo;

Von diesem Datentyp erstelle ich ein Array, anfangs mit Platz für nur ein Element und initialisiere es mit '\0'!

RecipientInfo	*parrRecip;
RecipientInfo	*arrRecip;

WORD			wtest = 0;
WORD			wtestold = 0;

arrRecip = (RecipientInfo *) malloc( sizeof(RecipientInfo) * 1 );
arrRecip = (RecipientInfo *) memset( arrRecip, '\0', sizeof(RecipientInfo) * 1 );

Anschließend verwendet mein Programm dieses Array. Nun kann es aber vorkommen, dass ich ein weiteres Array-Element benötige. Also vergrößere ich dieses Array:

wtest = sizeof(RecipientInfo) * (*wRecip + 1);
wtestold = sizeof(RecipientInfo) * *wRecip );
arrRecip = (RecipientInfo *) realloc( arrRecip, wtest );

Nun möchte ich das soeben neu allokierte Array-Element auch mit '\0' initialisieren. Wichtig hierbei ist, dass das schon vorhande erste Array-Element nicht erneut intitialisiert wird:

parrRecip = arrRecip + wtestold;
parrRecip = (RecipientInfo *) memset( arrRecip, '\0', sizeof(RecipientInfo) * 1 );

Das scheitert aber immer! Das neue Array-Element wird nicht mit '\0' initialisiert. Warum?

Viele Dank im Vorraus.

NicoP.

c.rackwitz

edit: hier stand unsinn. korrektur folgt:

bitte liefere ein ausfuehrbares beispiel.
pruefe rueckgabewerte der funktionen.
benutze einen debugger oder spicke das programm mit printf(), um den ablauf zu verfolgen.

edit2: mein fehler. ich sehs jetzt.
*ist das 1 in dem letzten codeschnipsel beabsichtigt?

nico.prenzel

Hallo,

danke für die prompte Reaktion.

Bei den hier abgebildeten Codeschnipseln, handelt es sich nur um ein auf das Minimum begrenzte Beispiel. Dies sollte doch zur logischen Kontrolle ausreichen, oder nicht?

Ja, das *1 im letzten Codeschnipsel ist beabsichtigt. Das Array wurde ja nur um ein weiteres Array-Element 1 * sizeof(RecipientInfo) vergrößert! Außerdem möchte ich ja auch nicht das ganze Array neu initialisieren, sondern nur das neu hinzugekommen Array-Element!

Mit nem Debugger bin ich auch schon durchgelaufen. Der lieferte mir ja die Erkenntnis, dass mein neu allokiertes Array-Element nicht neu initialisiert wurde!

Danke & Gruß.

NicoP.

c.rackwitz

dein letztes memset bearbeitet den alten pointer.

grund warum solche fehler passieren: scheussliche variablennamen. du solltest die namen nicht bis zur unkenntlichkeit abkuerzen und die praefixschreibweise nicht als religion praktizieren.

nico.prenzel

Hi,

so ein Mist.

Richtiger ist natürlich:

parrRecip = (RecipientInfo *) memset( parrRecip, '\0', sizeof(RecipientInfo) * 1 );

Allerdings funktioniert das so wie gewünscht immer noch nicht!

Noch eine Idee?

NicoP.

c.rackwitz

ganzes programm her, damit ich/wir es fuer dich debuggen koennen.

wenns geht auf das minimum reduziert, keine gui und so kram. am besten ist immernoch ein demoprogramm, welches wirklich nur den bug darstellt.

am besten waere aber immernoch, wenn du selber das problem einkreisen wuerdest.

nico.prenzel

Also gut!

Habe jetzt mal ein neues Testprogramm geschrieben.

Hier die RecipTest.c Datei:

#include "RecipTest.h"

int main(int argc, char* argv[])
{
	RecipientInfo	*arrRecip;
	WORD			wRecip = 0;

	RecipientInfo	*parrRecip;

	WORD			wtest = 0;
	WORD			wtestold = 0;

	WORD			counter;
	WORD			wRecipDomainLen;

	char			strRecipDomain[] = "test.com";

	arrRecip = malloc( sizeof(RecipientInfo) * 1 );
	arrRecip = memset( arrRecip, '\0', sizeof(RecipientInfo) * 1 );

	wRecipDomainLen = strlen(strRecipDomain);

	for( counter=0; counter < 3; counter++ )
	{

		if( counter >= 1 )
		{

			wtest = sizeof(RecipientInfo) * (counter + 1);

			wtestold = sizeof(RecipientInfo) * (counter );

			arrRecip = (RecipientInfo *) realloc( arrRecip, wtest );

			parrRecip = (RecipientInfo *) arrRecip + wtestold;

			printf( "address of arrRecip: %x", &arrRecip[1] );

			parrRecip = (RecipientInfo *) memset( parrRecip, '\0', sizeof(RecipientInfo) * 1 );
			//	arrRecip = (RecipientInfo *) memset( *arrRecip[1], '\0', sizeof(RecipientInfo) * 1 );

			printf("address of arrRecip: %x", &parrRecip[0] );

		}

		arrRecip[counter].strRecipientDomain = (char *) malloc( (wRecipDomainLen + 1) * sizeof(char) );
		arrRecip[counter].strRecipientDomain = (char *) memset( arrRecip[counter].strRecipientDomain, '\0', (wRecipDomainLen + 1) * sizeof(char) );

		arrRecip[counter].wRecipientDomainLen = wRecipDomainLen;

		memcpy( arrRecip[counter].strRecipientDomain, strRecipDomain, wRecipDomainLen );

	}

	return 0;

}

und hier die RecipTest.h Datei:

#include <windows.h>
#include <stdlib.h>
#include <malloc.h>

#include <stdio.h>

typedef struct
{
  char   *strRecipientDomain;
  WORD   wRecipientDomainLen;
  char   *strTests;         
  WORD   wTestsLen;

}   RecipientInfo;

Und nochmal was ich hiermit erreichen möchte:

Bei dem ersten Durchlauf der Schleife wird in das schon bereits allokierte Array-Element für die Variable strRecipientDomain, Speicher allokiert, diese initialisiert und anschließend mit Inhalt gefüllt.
In meinem richtigen Programm kann ich nicht vorhersehen wieviele Array-Element arrRecip groß sein muss! Deshalb wird beim zweiten Druchlauf der Schleife ein weiteres Array-Element zu arrRecip allokiert. Dieses, und nur dieses Array-Element soll nun mit '\0' initialisiert werden!

Dankeschön & gruß

NicoP.

c.rackwitz

inkrementierung von pointern passiert nicht byteweise, sondern um sizeof(*pointer) bytes:

RecipientInfo *foo = sonstwas;
foo = foo + 1; // naechstes element
foo = foo + sizeof(*foo); // semantisch falsch

dein fehler:

parrRecip = (RecipientInfo *) arrRecip + wtestold;