zeiger und lokale variablen

[RumbaRumba]

hello. ich verstehe etwas mit den char zeigern und lokalen char variablen nicht ganz. beides ergibt irgendwie das gleiche wenn ich das ganze mit dem typ int teste, kommt genau das erwartete ergebniss heraus. beispiel:

int zeiger und lokale int variable

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void FunctionWithPointer(int *p_number)
{
	*p_number = 20;
}
//---------------------------------------------------------------------------
void FunctionWithoutPointer(int number)
{
	number = 20;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
	int *number = new int;
    *number = 10;
    FunctionWithPointer(number);

    Edit1->Text = IntToStr(*number); //ausgabe gleich 20. Die variable wurde also direkt über den zeiger manipuliert.
    delete number;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
	int number = 10;
    FunctionWithoutPointer(number);

    Edit2->Text = IntToStr(number); //wie erwartet, ausgabe 10. Da hier ja nur eine kopie erstellt wird und kein zeiger übergeben wird.
}
//---------------------------------------------------------------------------

so habe ich das gelernt und so macht für mich das auch sinn. nur dort wo auch ein zeiger als parameter übergeben wurde kann der speicherinhalt geändert werden. bei einer kopie einer lokalen variable macht das ja keinen sinn oder verstehe ich etwas falsch? Nundenn... das beispiel mit einem char array:

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void FunctionWithoutPointer(char other_local[14])
{
	other_local[0] = 'B'; //greifft nicht über einen zeiger auf "local" zu, ändert jedoch den inhalt!!?
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
	char local[14];
    local[0] = 'A';
    FunctionWithoutPointer(local); //local wird als kopie übergeben!!?

    Edit2->Text = local; //unerwartete ausgabe: B
}
//---------------------------------------------------------------------------

wie gerade oben angesprochen trifft hier das phänomen ein. Aber eben nur mit einem typ char. Hier wird tatsächlich das lokale char array geändert. Ich sehe die logik irgendwie nicht warum das so sein soll und zudem auch nur bei einem char array oder char ansich. mit allen anderen elementarvariablen kommt sowas doch nicht vor? stehe nun echt auf dem schlauch.

[Caipi]

RumbaRumba schrieb:

wie gerade oben angesprochen trifft hier das phänomen ein. Aber eben nur mit einem typ char. Hier wird tatsächlich das lokale char array geändert.

Das liegt ganz einfach daran, dass Arrays per Referenz übergeben werden. Vergl.: local == &local[0]. D.h. hier wird einfach die Adresse des ersten Elements übergeben.

Ich sehe die logik irgendwie nicht

Kopieren entfällt. Und da das Kopieren bei c-style Arrays meistens sowieso nicht gewünscht ist, ist es das Default-Verhalten.

Gruß Caipi