Wissensdatenbank Wirtschaftsrecht

aktuelles Dokument: ProzProg9Zeiger
image4
image3
image2
image1
 Alle Kategorien:
  Forschungsdatenbank
  Lehrveranstaltungen
  Lexikon
  Literatur
  Rechtsgebiete
  Rechtsprechung
  Service
  Studium F H S
  Wissensmanagement
ich war hier: ProzProg9Zeiger

Version [22725]

Dies ist eine alte Version von ProzProg9Zeiger erstellt von RonnyGertler am 2013-03-28 20:20:48.

 

 (image: http://wdb.fh-sm.de/uploads/QualipaktLehre/BMBF_Logo_klein.jpg)

Prozedurale Programmierung - Kapitel 9 - Zeiger


Inhalte von Dr. E. Nadobnyh


C/C++ enthält ein umfangreiches Zeigerkonzept, welches einen direkten Zugriff auf den Speicherplatz ermöglicht.

Ein Zeiger ist eine Variable, die eine Adresse einer Variablen oder einer Funktion enthält.

Synonyme: Pointer, Pointervariable, Zeigervariable.

Man kann auf eine adressierte Variable oder Funktion indirekt über einen Zeiger zugreifen. Ein Zeiger adressiert eine Speicherstelle und gibt mit dem Typ an, wie diese Speicherstelle zu verwenden ist.


Bei Zeigern sind immer zwei unterschiedliche Typen verwickelt:

1) Zeigertyp (Pointertyp, Adresstyp) ist eigenen Datentyp des Zeigers und der Adresse.

2) Basistyp ist Typ der Variablen (des Objektes), auf die der Zeiger “zeigt“.

In C werden Zeiger auf eine Variable, auf eine Funktion, auf ein Feld und auf ein Zeiger definiert.


Zeiger auf eine Variable. Definition


Ein Zeiger wird wie jede andere Variable definiert: T* name;

Mit T* wird der Datentyp des Zeigers und mit T der Datentyp der adressierten Variable (Basistyp) bezeichnet.

Beispiel: int* p1; float* p2;

Die Zeigervariablen p1 und p2 haben die Datentypen „Zeiger auf int“ und „Zeiger auf float“.

Mit der Definition wird der Speicherplatz für den Zeiger reserviert. Ein Zeiger belegt bei einem 32-bit-Betriebs-system immer 4 Bytes.

Ein uninitialisierter Zeiger wird wie jede andere Variable mit dem zufälligen Wert oder mit 0 initialisiert. Die Verwendung des uninitialisierten Zeigers verursacht einen Fehler, der oft schwer zu finden ist.


Initialisierter Zeiger


Wie jede andere Variable erhält ein Zeiger einen sinnvollen Wert bei der Definition oder durch die Zuweisung.

Eine Variablenadresse kann z.B. mit dem Adressoperator erhalten werden.

Beispiel: int a=3; int* p=&a;

 (image: https://hssm.hqedv.de/uploads/ProzProg9Zeiger/pp55.gif)

Nach der Zeigerinitialisierung sagt man "p zeigt auf a".

⇒ Demo 1.


Nullzeiger


Ein Zeiger, der die Adresse NULL enthält, wird Nullzeiger (Nullpointer) genannt. Er zeigt auf kein gültiges Datenobjekt.

Es ist sinnvoll, Zeigervariablen mit NULL zu initialisieren, z.B.: double* p=NULL;

NULL ist als eine Adresse mit dem Wert 0 in der Standardbibliothek definiert.

Man sollt auch immer NULL statt den Zahlenwert 0 verwenden, denn es ist nicht sicher, ob die Länge einer Integer-Variablen auch der Länge einer Adresse entspricht.


Inhaltsoperator


Der Inhaltsoperator (Dereferenzierungsoperator, Verweisoperator, Indirektionsoperator) wird mittels * bezeichnet.

Er bildet ein Sprachkonstrukt *x, der als ein Verweis benannt wird. Statt x kann eine Adresse, ein Zeigername, ein Feldname usw. verwendet werden.

Die Ausführung eines Inhaltsoperators ist vom Kontext abhängig:

1) Wenn ein Verweis in einem Ausdruck steht, wird er auswertet, d.h. durch ein Wert ersetzt.
2) Wenn ein Verweis links vom Gleichheitszeichen steht, wird er als Zuweisung interpretiert.

Achtung: Begriffsverwirrung bei Verweis vs. Referenz, Zeiger, Punkt-Operator!


Impliziter Inhaltsoperator


Zur Laufzeit wird für jede Variable eine Adresse zugeordnet. Dabei wird der Variablenname durch den Verweis ersetzt.

Wenn der Variable a die Adresse 0012FF88 zugeordnet wird, dann kann z.B. die Zuweisung a=a+4; zur Laufzeit folgendermaßen aussehen:

 (image: https://hssm.hqedv.de/uploads/ProzProg9Zeiger/pp56.gif)

Der Verweis *(0012FF88) enthält den impliziten Inhaltsoperator * .


Inhaltsoperator und Zeiger


Die Verwendung des Inhaltsoperators *p bedeutet einen lesenden oder schreibenden Zugriff auf die Variable, deren Adresse im Zeiger p enthalten ist.

Beispiel:

    int a=3, tmp;  
    int* p = &a;      //statt a kann *p benutzt werden
    tmp = *p;         //lesender Zugriff auf die Variable a
    *p=5;               //schreibender Zugriff auf die Variable  


Achtung: Das Zeichen * in der Zeiger-Definition int* ist ein Teil der Typbezeichnung aber kein Inhaltsoperator.

⇒ Demo 2


Inhaltsoperator und Priorität


Bei der Verwendung des Operators * muß man die Priorität und Assoziativität von Operatoren genau beachten. Dies erscheint zunächst etwas schwierig, da dieser Operator ungewohnt ist.

Beispiele:

   int x=3;    
   int* px;        // px ist ein Zeiger auf int  
   px = &x;      // in px die Adresse von x speichern
   *px;             // Wert der Variablen x  
   *px + 1;      // Wert von x plus 1  
   *(px+1);     // Adresse in px erhöhen.  
                       // Inhalt der Nachbar-Variable
   *px += 1;    // Inhalt von x erhöhen  
   (*px)++;     // Inhalt von x inkrementieren  
   *px++;        // wie *(px++); wegen Assoziativität  
   *++px;        // wie *(++px); wegen Assoziativität  


9.2. Zeiger auf eine Variable. Details


Adresstyp T*


Jede Adresse hat einen bestimmten Typ, der als Adresstyp (auch Zeigertyp) bezeichnet wird.

Ein Adressoperator liefert eine Adresse vom Typ T*, wenn sein Argument vom Typ T ist.

Im folgenden Beispiel hat die Adresse den Typ int* :

int a=3; printf("%p", &a); //0012FF88

Einem Zeiger kann eine Adresse zugewiesen werden, die den gleichen Zeigertyp hat.

T a; T* p = &(a);

Ein Inhaltsoperator liefert einen Wert vom Typ T, wenn sein Argument vom Typ T* ist.

T* p; T a = *(p);

Legende: T – Datentyp, T* - Adresstyp.


Konvertierung von Adresstypen


Synonym: Typumwandlung von Zeigertypen.

Den Typ einer Adresse kann konvertiert werden. Der binäre Code der Adresse bleibt dabei unverändert. Die Konvertierung von Zeigertypen verwendet man z.B. in der objektorientierten Programmierung.

Eine implizite Zeigertypen-Konvertierung von eingebauten Datentypen ist nicht erlaubt, z.B.:

short b=4; short* pb=&b;
int* pa=pb; //Fehler: Konvertierung nicht möglich

Eine explizite Zeigertypen-Konvertierung ist nahezu immer ein logischer Fehler, z.B.:

pa=(int*)pb; //keine Fehlermeldung

⇒ Demo 3.


Zeiger und Konstanten


Wenn man einen Zeiger p benutzt, sind zwei Variablen beteiligt: der Zeiger und die Variable, auf die er zeigt (dereferenzierte Variable, Objekt).

 (image: https://hssm.hqedv.de/uploads/ProzProg9Zeiger/pp57.gif)

Es gibt drei Möglichkeiten const zu verwenden:

1. Zeiger auf konstante Variable, z.B.:

const int* p;
int const* p;

Eine Veränderung des Zeigers ist möglich.

2. Konstanter Zeiger auf Variable, z.B.:
int* const p ;

Eine Veränderung der Variablen ist möglich.

3. Konstanter Zeiger auf konstante Variable, z.B.:

const int* const p;
int const* const p;


Zeiger als Parameter


Ein Zeiger als Parameter stellt einen IN-OUT-Parameter dar. Die adressierte Variable kann in der Funktion gelesen und beschrieben werden. Eine Übergabe per Zeiger ist ähnlich wie call-by-reference.

Syntax für Prototyp und Aufruf:
void f(T* p); T a; f(&a ); T- Datentyp (Basistyp).

Diese Übergabe ist aber tatsächlich call-by-value. Der Parameter p wird beim Aufruf mit dem Wert des Arguments, d.h. mit der Adresse der Variablen a initialisiert.

Beispiele

int main()
{   int x=3, y;  
     scanf(“%i“, &y);
     swap(&x,  &y);  
     return 0;  
}

void swap(int* x, int* y)
{  int h = *x;  
    *x = *y;  
    *y = h;
}



Rückgabe per Zeiger


Synonym: Zeiger als Rückgabewert

Eine Rückgabe per Zeiger ist ähnlich wie Rückgabe per Referenz. Der Aufrufer erhält die Adresse der Variablen (des Objektes) und kann direkt mit dem Original arbeiten.

Syntax für Prototyp und Aufruf:
T* f( ); T* a = f(); T- Datentyp.


Beispiel:

int main()
{  int* a=f();  
    return 0;
}

int b=5;

int*  f( )
{ return &b;  
}


Eine Rückgabe per Zeiger ist tatsächlich die Rückgabe per Wert. Eine Adresse von Typ T* wird zurückgeliefert und kann einem Zeiger zugewiesen werden.

Bei der Manipulationen mit „großen“ Variablen (Objekten) kann man die Kopierarbeit reduzieren, wenn man statt Objekten Zeiger verwendet.

⇒ Demo 4.

Gefahren bei der Rückgabe per Zeiger:
Die Adresse von lokalen Variablen (Objekte) dürfen nicht zurückgegeben werden, weil sie nach dem Rückkehr verschwunden sind.

Negatives Beispiel :
Die lokale Variable existiert nur während der Funktionsausführung. Die Ausgabe ist unbestimmt, sie könnte zufällig auch 1234 lauten.

int main(void)  
{ int*  p = f();    
   printf("%d",  *p);  
   return 0;
}
int*  f(void)  
{  int x = 1234;
    return (&x);  
}



9.3. Adressarithmetik


Adressarithmetik


Als Adressarithmetik (Zeigerarithmetik, pointer arithmetic) bezeichnet man spezifische Adressoperationen mit beschränkte Möglichkeiten. Schwerpunkt ist die Behandlungvon Feldern.

Es sind natürlich nur Operationen erlaubt, die zu sinnvollen Ergebnissen führen:
1. Inkrement und Dekrement: ++, --.
2. Addition und Subtraktion mit ganzzahligem Wert.
3. Zeigersubtraktion.
4. Zeigervergleich: >, >=, <, <=, != und ==.
5. Alle anderen Operationen sind verboten.

Zeigersubtraktion und Vergleich ist nur dann sinnvoll, wenn beide Zeiger auf Elemente des gleichen Feldes zeigen.

Anmerkung: Arithmetische Operationen sind nicht erlaubt bei Zeigern auf Funktionen.


Name eines Feldelementes


In einem eindimensionalen Feld T a[N]; ist der Name eines Feldelementes aus einem Feldnamen a und einem Index i zusammengestellt: a[i]

Für eingebaute Datentypen T transformiert der Compiler diesen Namen zu äquivalenter Form:

a[i] ⇒ *(a + i).

Hier sind beteiligt:
* - ein Inhaltsoperator und
+ - eine Summe der Adressarithmetik.

Beispiel: int a[2], b[2]; int i=1;

a[i]=5; ⇒ *(a + i) = 5;

a[0] = b[0]; ⇒ *(a+0)=*(b+0); ⇒ *a=*b;










CategoryProzProg
Diese Seite wurde noch nicht kommentiert.
Valid XHTML   |   Valid CSS:   |   Powered by WikkaWiki