Pointerfrage (wiedermal)

[MiesePointer (Gast)]

Hi,

ich steh gerade etwas aufm schaluch bzw sehe den Wald vor lauter Wäldern 
nicht mehr.

Ich möchte den Inhalt einer Variablen in ein anderes Modul haben, ihn 
dort Verädern und dann wieder zurück ins Modul haben. Dabei würde ich 
gern mit Pointern arbeiten. Aber irgendwie steh ich gerade neben mir.

int* VariableLesen (void)
{ 
  return &Variable;              // Addresse in den Pointer
}

void VariableSchreiben (int* NewValue )
{
  Variable = *NewValue;          // Dereferenzierten Pointer wieder übernehmen
}

in dem Anderen Modul:

int* temp = VariableLesen();
temp++;
VariableSchreiben( temp );

Geht aber nicht, der Variableninhalt wird nicht verändert, sicher nur ne 
Kleinigkeit, aber ich seh sie gerade nicht...


Danke

[pointR (Gast)]

probiers mal mit *temp++ ;-)

[Peter II (Gast)]

MiesePointer schrieb:
(*temp)++;


aber was soll das hier?

> int* VariableLesen (void)
> {
>   return &Variable;              // Addresse in den Pointer
> }

was für ein Type ist Variable? Ein zeiger oder ein Wert?

[MiesePointer (Gast)]

Ein Wert

[Karl H. (kbuchegg)]

MiesePointer schrieb:

> Ich möchte den Inhalt einer Variablen in ein anderes Modul haben, ihn
> dort Verädern und dann wieder zurück ins Modul haben. Dabei würde ich
> gern mit Pointern arbeiten.

Warum?
Man arbeitet nicht mit Pointern, wenn man nicht muss oder zumindest 
einen extrem guten Grund hat.


> int* temp = VariableLesen();
> temp++;

Hier erhöhst du den Pointer und nicht das worauf er zeigt.

> Geht aber nicht, der Variableninhalt wird nicht verändert, sicher nur ne
> Kleinigkeit,

Eigentlich keine Kleinigkeit.
Denn dein ganzer Ansatz zeigt, dass du Pointer nicht verstanden hast.


Entweder: komplett ohne Pointer

int Wert = 5;

int get()
{
  return Wert;
}

void set( int newVal )
{
  Wert = newVal;
}

int main()
{
  int i = get();   // den bisherigen Wert holen
  i++;
  set( i );        // und den veränderten Wert setzen lassen
}

... und das ist die bevorzugte Variante!


oder eben, in dem das Modul einen Pointer rausrückt und so dem Aufrufer 
ermöglicht direkt, ohne Umweg, sich an der Variablen zu schaffen zu 
machen. Und weil das verwendende Modul sich direkt an der Variablen 
(über den Pointer) zu schaffen macht, braucht man auch keine 
Set-Funktion mehr. Und genau da liegt der Grund, warum man diesen Weg 
eigentlich nicht machen will: Eine Set Funktion hätte immer noch die 
Möglichkeit, den neu zu setzenden Wert zu überprüfen (zb auf 
Sinnhaftigkeit, auf Bereichsgrenzen etc.). Durch Herausgabe des Pointers 
hat sich das Modul ganz dem Aufrufer ausgeliefert, dass der keinen 
Fehler macht. Der kann jeden beliebigen Wert in die Modul-Variablen 
schreiben, ob die Sinn machen oder nicht.

int Wert;

int* get()
{
  return &Wert;
}


int main()
{
  int* ptrToVariable = get();

  // An dieser Stelle hat main die Adresse von 'Wert', auch wenn
  // es nicht weiß, wie die Variable heißt.
  // Jegliche Manipulation über *ptrToVariable manipuliert bereits
  // direkt die Variable "Wert"

  (*ptrToVariable)++;
}

[reviewing (Gast)]

@Karl Heinz

Danke für diese ausführliche und verständliche Erklärung!

[MiesePointer (Gast)]

Wiedereinmal hast du Recht gehabt Karl Heinz,

ich wollte es so schnell wie möglich machen, aber auf die "normale" 
Weise gehts natürlich auch!


Danke

[Karl H. (kbuchegg)]

MiesePointer schrieb:
> Wiedereinmal hast du Recht gehabt Karl Heinz,
>
> ich wollte es so schnell wie möglich machen

Das ist ja auch sinnvoll, wenn das Modul etwas liefert, was etwas 
umfangreicher wie ein int ist. Eine Struktur aus einer Datenbank oder 
ein Bild zum Bleistift. Dann ist es schon ok, wenn das Modul einen 
Pointer liefert. Entweder als const Pointer, damit der Aufrufer das 
Signal kriegt: "Hier hast du einen Pointer, aber bitte lass die Daten in 
Ruhe"
oder eben absichtlich und gezielt (und mit Zähneknirschen) einen 
Pointer, damit der Aufrufer die Daten manipulieren kann ohne jedesmal 
durch 25 Softwareschichten und 78 Funktionsaufrufe zu müssen.

[Bronco (Gast)]

MiesePointer schrieb:
> Ich möchte den Inhalt einer Variablen in ein anderes Modul haben, ihn
> dort Verädern und dann wieder zurück ins Modul haben.

Man könnte auch eine globale Variable verwenden.

[MiesePointer (Gast)]

Bronco schrieb:
> Man könnte auch eine globale Variable verwenden.
Klar, aber das ist immer blöde wenn das Projekt größer wird, dann blickt 
keine Sau mehr durch wer wo an welchen Daten hebelt, daher versuche ich 
es alles zu kapseln...