Char-Zeiger. Verständisproblem

Hi,

ich habe eine struct die gefüllt werden muss:

struct Info
{
char *Name;
char *Message;
};

Das ganze geschiebt über eine Funktion:

void Enter( const char *Name_, const char *Message_ )
{
Info Temp;
Temp.Name = Name_;     // Das kann ja so nicht gehen...
Temp.Message = Message_; // und das auch nicht, aber wie weise ich denen nun die Werte zu ohne Speicherleaks oder sonstwas zu haben?
}

Vielen Dank. Gruß

pale dog

Chaar schrieb:

Temp.Name = Name_;     // Das kann ja so nicht gehen...
Temp.Message = Message_; // und das auch nicht, aber wie weise ich denen nun die Werte zu ohne Speicherleaks oder sonstwas zu haben?
}

klar geht das. man kann char-pointer weiterreichen und anderen char-pointern zuweisen.

pale dog schrieb:

Chaar schrieb:
Temp.Name = Name_;     // Das kann ja so nicht gehen...
Temp.Message = Message_; // und das auch nicht, aber wie weise ich denen nun die Werte zu ohne Speicherleaks oder sonstwas zu haben?
}
klar geht das. man kann char-pointer weiterreichen und anderen char-pointern zuweisen.

Ja natürlich geht das, aber was ist mit SPeicherleaks etc.? Wird die Adresse nicht irgendwann vernichtet...?

pale dog

Chaar schrieb:

Ja natürlich geht das, aber was ist mit SPeicherleaks etc.?

ich versteh' nicht ganz was du meinst. meinst du in verbindung mit 'malloc' ?

codefrag

Chaar schrieb:

pale dog schrieb:
Chaar schrieb:
Temp.Name = Name_;     // Das kann ja so nicht gehen...
Temp.Message = Message_; // und das auch nicht, aber wie weise ich denen nun die Werte zu ohne Speicherleaks oder sonstwas zu haben?
}
klar geht das. man kann char-pointer weiterreichen und anderen char-pointern zuweisen.
Ja natürlich geht das, aber was ist mit SPeicherleaks etc.? Wird die Adresse nicht irgendwann vernichtet...?

Hi,
ja wenn du es darauf beziehst... die Ableitung von der Struct existiert nur lokal in der Funktion Enter(). Das hat aber nichts mit Speicherleaks zu tun

Wenn du diese weiterhin nutzen willst, dann musst du diese in main() mit malloc allokieren..

Also z.B. so:

struct myInfo { char *Name; char *Message; };

void Enter( const char *Name_, const char *Message_,  struct myInfo *point_ );

int main()
{
  myInfo *p_info;
  p_info = malloc(sizeof(myInfo));

  Enter( "Name" , "Message" ,  p_info )
  return 0;
}

void Enter ( const char *Name_, const char *Message_,  struct myInfo *point_ )
{
  // Hier mach was
  point_->Name = Name_;

}

Nur so getippt... also keine Vollstädnigkeit auf Syntax

CStoll

Das mußt du nichtmal mit malloc anlegen, dort kannst du auch eine (in main()) lokale Variable verwenden:

int main()
{
  myInfo pt;
  Enter("Name","Message",&pt);
}

//Enter() wie in Codefrag's Beispiel

Was die Speicherlecks angeht: Die werden erst kritisch, wenn du Speicher per malloc() anforderst und anschließend vergisst, ihn wieder freizugeben. In deinem ursprünglichen Beispiel ist das kein Problem - der aufrufende Code hat den Speicher angefordert und wenn du dort keinen Mist baust, hat er nach Funktionsende auch weiterhin die Adresse und kann den Speicher wieder freigeben.

Hi,

die Struktur wird noch mit push_back an einen std::vector angefügt! Ich weiß das es C++ ist, aber wie sieht es nun aus? Kann ich es noch immer so belassen oder muss ich mir jetzt Sorgen machen!?

Danke

Gruß

CStoll

Das kommt ganz auf die Details an, die wir von hier aus nicht sehen können Die Funktion selbst, wie du sie dort oben gepostet hast, produziert keine Speicherlecks - wenn du da Probleme hast, liegt es an der Einbindung der Funktion in dein Programm.

Don06

Nur mal so nebenbei:
Ahhh! Du arbeitest mit C++ und schlägst dich noch mit C-Strings(char-Arrays/Pointern) rum?
Nimm std::string und es werden keine Probleme auftreten.

Eine Frage hab ich da aber doch noch. Wieso geht sowas in C und C++:

void foo(char* p)
{
    p[4] = 'i'; // sowas geht ja jetzt ;)
}

int main()
{
    foo("Hallo"); // Sollte hier nicht gewarnt werden,
                  // weil der Parameter nicht const ist?
    return 0;
}

GCC komiliert das ohne Fehler oder Warnungen (sowohl im C als auch im C++ Modus), aber das Programm stürzt (natürlich) ab.

Gruß
Don06

CStoll

Weil im ANSI-Standard mal festgelegt wurde, daß ein String-Literal ein (nicht-constanter) char* sein soll.