Array von Strukturen an Funktion

gs_zk_sed

Hallo zusammen!

Wie kann ich ein dynamisches Array von Strukturen als Referenz an eine Funktion übergeben? Ich möchte in der Funktion erst entscheiden, wie auf wieviele Elemente das Array dimensioniert wird. Es soll dort gleich mit Werten gefüllt werden und der aufrufenden Funktion schließlich wieder zur Verfügung stehen. Irgend etwas habe ich daran noch nicht verstanden. Hier mein bisheriger Quelltext als Testprogramm:

#include <string>
#include <iostream>
#include <stdlib.h>

using namespace std;
struct tStruct
{
  string Inhalt;
};

void vFunction(struct tStruct **MyStructFunction)
{
  *MyStructFunction = new (nothrow) tStruct[6];
	if (*MyStructFunction == (tStruct *) 0)
  { return; }

  for (unsigned int i = 0; i < 5; i++)
  { MyStructFunction[i]->Inhalt = string("test"); }
  return;
}

int main(int argc, char *argv[])
{
  struct tStruct *MyStruct = NULL;
  vFunction(&MyStruct);
  if (MyStruct == NULL)
  { return -1; }

  for (unsigned int i = 0; i < 5; i++)
  { printf ( (char *) (MyStruct[i].Inhalt.c_str())); }
  delete [] MyStruct;
  MyStruct = NULL;

  system("PAUSE");	
  return 0;
}

Wer kann mir dabei helfen?

Grüße

Steffen

#include <string> 
#include <iostream> 

struct Struct 
{ 
  std::string content;  // entweder englische oder deutsche namen bitte
}; 

void foo ( Struct*& myStruct )  {  // nicht struct tStruct **MyStructFunction 
  myStruct = new ( std::nothrow ) Struct [ 6 ]; 
    if ( !myStruct )  // einfacher als == NULL und kein NULL mehr bitte
      return; 

  for ( unsigned int i = 0; i < 5; i++ ) 
    myStruct [ i ].content = "test"; 
} 

int main () 
{ 
  Struct* myStruct = 0;  // 0 ist besser als NULL
  foo ( myStruct );

  if ( !myStruct ) 
    return -1; 

  for ( unsigned int i = 0; i < 5; i++ ) 
    std::cout << myStruct [ i ].content << '\n'; 

  delete [] myStruct; 
  MyStruct = 0; 

  std::cin.clear ();
  std::cin.ignore ( std::cin.rdbuf () -> in_avail () );
  std::cin.get ();

    // system ( "PAUSE" ) bitte auch nicht mehr verwenden, steht sicher in irgendeinem faq warum 

  return 0; 
}

ausserdem: darueber kann man sich sicher endlos streiten, aber wenn schon dann entweder c oder c++ coden; beides mixen sieht nicht nur sonderlich aus, es kann auch zu komplikationen fuehren.

was auch immer

C++ Forumbot

Dieser Thread wurde von Moderator/in cd9000 aus dem Forum WinAPI in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

volkard

void foo ( Struct*& myStruct )  {  // nicht struct tStruct **MyStructFunction 
//doch, zeiger auf zeiger ist besser, wenn man zeiger auf zeiger meint.
  myStruct = new ( std::nothrow ) Struct [ 6 ]; 
//warum nothrow?
    if ( !myStruct )  // einfacher als == NULL und kein NULL mehr bitte
      return; 
//warum unsigned int, entweder schlicht int oder gleich size_t. 
//dann aber auch != und ++i
  for ( unsigned int i = 0; i < 5; i++ ) 
    myStruct [ i ].content = "test"; 
}

nee.

Struct* foo() {
  Struct* myStruct = new Struct [ 6 ]; 
  for ( int i = 0; i != 6; ++i ) 
    myStruct [ i ].content = "test"; 
}

und fertig.

gs_zk_sed

Hi volkard,

ich wollte das Array nicht als Rückgabetyp, sondern als Referenz.

Klappt jetzt alles...

otze

wieso willste es als referenz? als zeiger ist es a) einfacher und b) kommts aufs selbe hinaus.

gs_zk_sed

Die Lösung von "was auch immer" funktioniert genau so, wie ich es haben wollte. Denn ich möchte mehrere Arrays in der Funktion verarbeiten. Das macht sich mit einem Rückgabetyp schlecht.