Array dynamisch vergrößern und an aufrufende Funktion zurückgeben?

[nico.prenzel]

Hallo,

nachdem mir bei der Inkrementierung von Pointern sehr gut weitergeholfen wurde (Dankeschön an c.rackwitz), habe ich auch schon die nächste Frage!

Folgendes Testprogramm habe ich vorbereitet.
Ich allokiere in der main-Funktion Speicher für ein Array, dass auf einer Struktur basiert. Die Größe dieses Array wird vorerst auf ein Element allokiert. Anschließend rufe ich die Funktion

buildRecipientArray( &*arrRecip, &wRecip );

auf und übergebe die Adresse des Pointers des Arrays(ist das korrekt?). Innerhalb der Funktion vergrößere ich das übergebene Array und kopiere einen String in die

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

-Variable.
Nachdem ich aus der Funktion zurückkehre befindet sich mein Pointer leider noch auf der Adresse, bei der er sich schon beim Aufruf der Funktion befand. Durch die Funktion realloc() bekam er jedoch innerhalb der Funktion eine andere Adresse!

Wie kann ich den neuen Zeiger des vergrößerten Arrays der main-Funktion zurückgeben? Wichtig: Da in meinem richtigen Programm zwei Arrays übergeben und vergrößert werden, kann ich wahrscheinlich() die return Anweisung nicht benutzen, oder?

Vielen Dank & Gruß

NicoP.

RecipTest.h:

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

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

}   RecipientInfo;

buildRecipientArray( RecipientInfo *arrRecipients, WORD *wRecip );

RecipTest.c:

#include "RecipTest.h"

int main(int argc, char* argv[])
{

	RecipientInfo	*arrRecip;
	WORD			wRecip = 1;

	WORD			i;

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

	buildRecipientArray( &*arrRecip, &wRecip );

	for( i = 0; i < wRecip; i++ )
	{

		printf( "arrRecip[%d].strRecipientDomain: %s\n", i, arrRecip[i].strRecipientDomain );

	}

}

buildRecipientArray( RecipientInfo *arrRecip, WORD *wRecip )
{

	RecipientInfo	*pold;

	RecipientInfo	*parrRecip;

	WORD			wtest = 0;
	WORD			wtestold = 0;

	WORD			counter;
	WORD			wRecipDomainLen;

	char			strRecipDomain[] = "test.com";

	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 = arrRecip;
			parrRecip = parrRecip + counter; // naechstes element

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

		}

		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;

}

[CStoll]

Das Stichwort heißt "Übergabe per Referenz/Pointer":

void resize(stype**data,int size,int nsize)
{
  *data=realloc(*data,sizeof(stype)*nsize);
}

(btw, die Operatoren & und * heben sich gegenseitig auf)