====== Aufgaben zu Zeigern =====

===== Aufgabe 1 =====

<box 100% round green|Aufgabe 1: Verständnisübung mit Zeigern>
Nach den Definitionen

<code cpp>
  int i=5, j=7;
  int *pi, *pj;
</code>

sollen die folgenden Zuweisungen in einem Programm stehen:

<code cpp>
  pi=i; 
  pi=&i;
  *pi=i;
  *pi=&i;
  pi=j;
  pj=&j;
  pi=*pj;
  j=*pi;
  *pi=i**pj;
  pi=0;
</code>

/*
++++ Lösung:|

<code cpp>
#include <iostream>
using namespace std;

int main()
{ int i=5, j=7;
  int *pi, *pj;

  // pi=i;  falsch, inkompatible Typen;

  pi = &i;
  cout << "Variable i = " << i << ", Adresse von i = " << &i << endl; 
  cout << "Pointervariable pi = " << pi << endl << endl; 


  *pi=13;
  cout << "Variable i = " << i << ", Adresse von i = " << &i << endl; 
  cout << "Pointervariable pi = " << pi << endl << endl; 

  // *pi=&i; falsch, auf integer-Typ kann kein adress-Typ zugewiesen werden
  // pi=j;  falsch, auf adress-Typ kann kein integer-Typ zugewiesen werden

  pj=&j;
  cout << "Variable j = " << j << ", Adresse von j = " << &j << endl; 
  cout << "Pointervariable pj = " << pj << endl << endl; 
  
  // pi=*pj; falsch, da *pj vom Typ integer ist, pi hat adress-Typ

  j=*pi;
  cout << "Variable i = " << i << ", Pointervariable pi = " << pi << endl; 
  cout << "Variable j = " << j << endl << endl; 
  
  cout << "Variable i vor Zuweisung = " << i << endl;
  cout << "Variable j vor Zuweisung = " << j << endl; 
  *pi=i**pj;  // identisch mit i=i*j bzw. i*=j; 
  cout << "Variable i nach Zuweisung = " << i << endl;
  cout << "Variable j nach Zuweisung = " << j << endl << endl; 

  cout << "Pointervariable pi vor Zuweisung = " << pi << endl;
  pi=0;
  cout << "Pointervariable pi nach Zuweisung = " << pi << endl << endl;
  
    
  system("PAUSE");
  return EXIT_SUCCESS;
}
</code>

++++
*/

Gib an, welche dieser Zuweisungen syntaktisch korrekt sind. Gib außerdem für jeden syntaktisch korrekten Ausdruck den Wert der linken Seite an, wobei die Ergebnisse der zuvor ausgeführten Anweisungen vorausgesetzt werden sollen. Falls die linke Seite ein Zeiger ist, gib den Wert der dereferenzierten Variablen an.
</box>

===== Aufgabe 2 =====

<box 100% round green|Aufgabe 2: Verständnisübung mit Zeigern>

Beschreibe das Ergebnis der folgenden Anweisungen:
<code cpp>
  int j=10;
  int* p=&j;
  *p=17;
  Memo1->Lines->Add(IntToStr(j));
  Memo1->Lines->Add(IntToStr(*p));
</code>

</box>

===== Aufgabe 3 =====

<box 100% round green|Aufgabe 3: Verständnisübung mit Zeigern>

Beschreibe das Ergebnis der folgenden Anweisungen:
<code cpp>
  int* f_retp()
  {
  int x=1;
  return &x;
  }  
...

  Memo1->Lines->Add(IntToStr(*f_retp()));
</code>

</box>

===== Aufgabe 4 =====

<box 100% round green|Aufgabe 4: Verständnisübung mit Zeigern>

Beschreibe für die Funktion
<code cpp>
int f(int a, bool b, bool c, bool d)
{
  int* p; int* q; int x=0;
  if (a==1) { p=0; q=0; }
  else if (a==2) { p=new int(17); q=new int(18); }
  else if (a==3) { p=&x; q=&x; }
  if (b) p=q;
  if (c) x=*p+*q;
  if (d) { delete p; delete q; }
  return x;
}
</code>
das Ergebnis der Aufrufe:

a) ''f(0,false,true,true);''\\
b) ''f(1,false,false,true);''\\
c) ''f(2,false,true,false);''\\
d) ''f(2,true,true,true);''\\
e) ''f(3,true,true,true);''\\
f) ''f(3,true,true,false);''\\

</box>

===== Aufgabe 5 =====

<box 100% round green|Aufgabe 5: Verständnisübungen mit Zeigern>Erstelle zwei Zeiger pAS1 und pAS2 auf zwei AnsiStrings.\\
a) Belege die beiden Speicherplätzen, auf die die beiden Zeiger zielen, jeweils einen kurzen Text zu und gib diesen aus.\\
b) Führe die Zuweisung ''pAS2=pAS1;'' aus und erkläre mit einer Graphik, warum nun beide Ausgaben den gleichen Text liefern.\\
c) Führe die Zuweisung ''pAS2=pAS1;'' aus, gib ''*pAS2'' aus, verändere den Text auf den ''pAS2'' zeigt und gib dann ''*pAS1'' aus. Erkläre wieder mit einer Graphik was hier geschieht.\\
d) Deklariere zwei Variablen ''AS1,AS2'' und weise ihnen einen Text zu. Deklariere zwei weitere Pointervariablen ''pAS3,pAS4'' und lasse sie (mittels Adressoperator) auf jene Speicherbereiche zeigen, die durch die Variablen ''AS1'' und ''AS2'' besetzt werden.\\ 
e) Lasse den Zeiger ''pAS1'' auf den Speicherinhalt von ''AS2'' und den Zeiger ''pAS2'' auf den Speicherinhalt von ''AS1'' zeigen.\\
f) Lasse einen der beiden Zeiger auf die definierte Leerstelle (''NULL'') zeigen und versuche auszugeben, wohin beide Zeiger zielen.
</box>

/*
++++ Lösung|
<code cpp>
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "ZeigerUnit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
AnsiString *pAS1;
AnsiString *pAS2;
// Alternative Kurzvariante
//AnsiString *pAS1=new AnsiString, *pAS2=new AnsiString;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{ pAS1=new AnsiString;
  pAS2=new AnsiString;
  *pAS1="Erster Text!";
  *pAS2="Zweiter Text!";
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{ // a) Normale Ausgabe
  Memo1->Lines->Add(*pAS1);
  Memo1->Lines->Add(*pAS2);

  // b) Eine Zuweisung
  // Übung
  // pAS2 = pAS1;
  // Memo1->Lines->Add(*pAS1);
  // Memo1->Lines->Add(*pAS2);

  // c) Indirekte Veränderung eines Speicherbereichs
  // pAS2 = pAS1;
  // Memo1->Lines->Add(*pAS2);
  // *pAS2= "Dritter Text";
  // Memo1->Lines->Add(*pAS1);

  // d) Verwendung von Speicher-Adressen
  // AnsiString AS1,AS2;
  // AnsiString *pAS3, *pAS4;
  // AS1="Neuer erster Text";
  // AS2="Neuer zweiter Text";
  // pAS3=&AS1;
  // pAS4=&AS2;
  // Memo1->Lines->Add(*pAS3);
  // Memo1->Lines->Add(*pAS4);

  // e) Vertauschung
  // pAS1=&AS2;
  // pAS2=&AS1;
  // Memo1->Lines->Add(*pAS1);
  // Memo1->Lines->Add(*pAS2);

  // f) "Ins definierte Leere" zeigen
  *pAS1="Schönen Nachmittag!";
  pAS2=NULL;
  Memo1->Lines->Add(*pAS1);
  if (pAS2==NULL) Memo1->Lines->Add("Zeiger pAS2 zeigt auf NULL");

}
</code>
++++
*/

===== Aufgabe 6 =====




<box 100% round green|Aufgabe 6: Verständnisübung mit Zeigern>
a) Erkläre, an welcher Stelle und warum das folgende Programm (erst während der Laufzeit) einen Fehler meldet.\\
b) Verändere das Programm so, dass der Inhalt beider Speicherstellen (auf die die beiden Zeiger zielen) ausgegeben wird.
</box>

<code cpp>
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Pointer1Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
int *pi1, *pi2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button1Click(TObject *Sender)
{
 int zahl1=13,zahl2=17;
 pi1=&zahl1;
 *pi2=zahl2;
 Memo1->Lines->Add("Inhalt des Speicherpatzes auf den pi1 zeigt: "+IntToStr(*pi1));
 Memo1->Lines->Add("Inhalt des Speicherpatzes auf den pi2 zeigt: "+IntToStr(*pi2));
}
//---------------------------------------------------------------------------
</code>