Grundlagen: Strings über Funktion verändern

WoWe

Hallo zusammen,

ich möchte euch mal fragen ob es dazu etwas auszusetzen gibt ?
Also, ich möchte ein char-Array und einen AnsiString über eine Funktion per Referenz oder Pointer verändern:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

AnsiString sMyString;
char cMyCharArray[128];

// Prototypen
bool __fastcall MyFunctionR( char & );   // call by Reference
bool __fastcall MyFunctionP( char * );   // call by Pointer
bool __fastcall MyFunctionsR( AnsiString & );   // call by Reference
bool __fastcall MyFunctionsP( AnsiString * );   // call by Pointer
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 // Initialisieren von char-Array und String
 strcpy( cMyCharArray, Edit2->Text.c_str());
 sMyString = Edit3->Text;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::btnCharZeigerClick(TObject *Sender)
{
 bool bResult;

 bResult = MyFunctionP( cMyCharArray );
 Edit1->Text = cMyCharArray;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::btnCharReferenzClick(TObject *Sender)
{
 bool bResult;

 bResult = MyFunctionR( *cMyCharArray );
 Edit1->Text = cMyCharArray;
}
//---------------------------------------------------------------------------

// char Parameterübergabe per call by reference
bool __fastcall MyFunctionR( char &rcTemp )
{
 char cbuff[128] = {0};

 strcat( cbuff, "Referenz, " );
 strcat( cbuff, Form1->ComboBox1->Text.c_str() );
 strcpy( &rcTemp, cbuff );
}
//---------------------------------------------------------------------------

// char Parameterübergabe per call by pointer
bool __fastcall MyFunctionP( char *pcTemp )
{
 char cbuff[128] = {0};

 strcat( cbuff, "Zeiger, " );
 strcat( cbuff, Form1->ComboBox1->Text.c_str() );
 strcpy( pcTemp, cbuff );
}
//---------------------------------------------------------------------------

void __fastcall TForm1::btnStringZeigerClick(TObject *Sender)
{
 bool bResult;

 bResult = MyFunctionsP( &sMyString );
 Edit4->Text = sMyString;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::btnStringReferenzClick(TObject *Sender)
{
 bool bResult;

 bResult = MyFunctionsR( sMyString );
 Edit4->Text = sMyString;
}
//---------------------------------------------------------------------------

// AnsiString Parameterübergabe per call by reference
bool __fastcall MyFunctionsR( AnsiString &rsTemp )
{
 AnsiString sString;

 sString = "Referenz, ";
 rsTemp = sString + Form1->ComboBox2->Text;
}
//---------------------------------------------------------------------------

// AnsiString Parameterübergabe per call by pointer
bool __fastcall MyFunctionsP( AnsiString *psTemp )
{
 AnsiString sString;

 sString = "Zeiger, ";
 *psTemp = sString + Form1->ComboBox2->Text;
}
//---------------------------------------------------------------------------

Gibt es daran irgend was auszusetzen ???

Danke und Gruß

WoWe

Christoph

Ja.

1. Sowas ist nicht sehr effizient:

WoWe schrieb:

AnsiString sString; 
 
 sString = "Referenz, "; 
 rsTemp = sString + Form1->ComboBox2->Text;

Warum nicht so?

rsTemp = "Referenz, " + Form1->ComboBox2->Text;

Genauso hier:

bool bResult; 
 
 bResult = MyFunctionP( cMyCharArray );

Mach das besser so, sonst sieht das wie C-Code aus:

bool bResult = MyFunctionP( cMyCharArray );
// Oder gleich:
return  MyFunctionP( cMyCharArray );

2. "// char Parameterübergabe per call by reference" ist eher unüblich. Man nimmst eine string-Klasse oder char*, aber nicht char&.

3. Globale Variablen.

WoWe

Hi cd9000,

vielen Dank für deine Anregungen. Warum würdest du bei 2. keine Reference nehmen ? Hat das irgend einen Grund oder eher "macht man halt so" ?

und bei 3. wie würdest du hier die globalen Variablen verhindern ? Wenn diese char Arrays und Strings von mehreren Units gelesen werden ?

Christoph

Zu 2.:
char* ist eigentlich ein Zeiger auf ein oder mehrere char. Es hat sich aber eingebürgert das String zu nennen.
char& ist normalerweise eine Referenz auf ein char. Außer diesem semantischen Grund gibt es noch einen anderen:
Wie willst du z.B. den Speicher (falls du ihn mit new angefordert hast) wieder löschen?
delete &referenz; funktioniert zwar, ist aber kein guter stil, da die Referenz danach ungültig und gefährlich ist.

Zu 3.:
Denk nicht in Units und globalen Funktionen/Variablen.
Bei C++ handelt es sich um Objekte und ihre Beziehungen untereinander. Globale Variablen sprechen von schlechtem Stil.

WoWe

Das globale Variablen ein schlechter Stil sind ist mir bekannt, aber wie würdest du bei meinem konkreten Beispiel ein char-Array oder AnsiString umgehen ?

Mir fehlt da irgendwie die Idee ? Auch mit deinem Tipp Units versus Objekte komme ich noch nicht viel weiter. Kannst du das ein bischen näher erklären ?

Christoph

Das hängt vom Verwendungszweck des Strings ab. "sMyString" ist nicht sehr aussagekräftig.
Beschreib bitte etwas genauer, was die Aufgabe dieses globalen Strings ist.

WoWe

Das sollte nur ein Beispiel sein mit dem man einen String verändert bzw. erweitert, ohne den String zu übergeben und dann wieder per return zurückzugeben. Der String könnte der Benutzername oder ein Verzeichnispfad sein, der von mehreren Units gelesen wird und aus diesem Grund global ist.

Ansonsten müsste man den String ja immer hin und her schicken.

junix

cd9000 schrieb:

Warum nicht so?

rsTemp = "Referenz, " + Form1->ComboBox2->Text;

Weil man von Hard-Coded, über das Ganze Projekt in source-Files verteilte Strings sowieso abstand nehmen sollte und die Strings an einem Ort sammeln? (o;

-junix

nman

WoWe schrieb:

Ansonsten müsste man den String ja immer hin und her schicken.

Nicht wenn Du eine get-Methode in eine geeignete Klasse bastelst die eine (uU konstante) Referenz zurückgibt.