1. Dashboard
  2. Forum
    1. Unerledigte Themen
  3. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team-Mitglieder
    4. Trophäen
    5. Mitgliedersuche
  4. Tutorial Bereich
  • Anmelden
  • Registrieren
  • Suche
Dieses Thema
  • Alles
  • Dieses Thema
  • Dieses Forum
  • Seiten
  • Forum
  • Lexikon
  • Erweiterte Suche
  1. Informatik Forum
  2. Webmaster & Internet
  3. Entwicklung

once again: Pointers

  • sommeralex
  • 17. Juli 2005 um 13:01
  • Unerledigt
  • sommeralex
    11
    sommeralex
    Mitglied
    Punkte
    1.325
    Beiträge
    188
    • 17. Juli 2005 um 13:01
    • #1

    Hallo!

    ein gutes beispiel zu pointern ist folgendes (aus "C for Java Programmers" von J.Maassen - trotzdem ist mir immer noch einiges nicht klar..:

    #include <studio.h>

    int j, k;
    int *ptr;

    int main (void)
    {

    j = 1;
    k = 2;
    ptr = &k;

    printf("j has value %d and is stored at %p\n", j, &j);
    printf("k has value %d and is stored at %p\n", k, &k);
    printf("ptr has value %p and is stored at %p\n", ptr, &ptr);
    printf("value of integer ppointed to by ptr is %d\n", *ptr);

    return 0;

    }


    /* OUTPUT */

    j has value 1 and is stored at 0x804972c
    k has value 2 and is stored at 0x8049734
    ptr has value 0x8049734 and is stored at 0x8049730
    value of integer pointed to by ptr is 2;

    /* Output ende */


    Soweit, so gut.


    1) Warum aber kann ich gewisse pointer deklararationen nur VOR der Main Methode machen?
    2) Bzw: Wie unterscheiden sich Deklarationen vor der Main Methode, sowie in der Main Methode?

    Beispielsweise funktioniert folgendes nicht (warum?):

    #include <blabla>

    struct object p{

    };

    //zeiger auf object struct
    struct interval *pa;
    //zeiger pa zeige auf p
    pa = &p;

    main{
    //blabla
    }


    geht nicht, fehlermeldung: "Redeclaration of 'pa' previously declared" aber:

    #include<blabla>

    struct object p{

    };

    //initialisieren + deklarieren aufeinmal
    struct interval *pa = &p;

    main{
    //blabla
    }


    es ist mir bewusst, dass ein pointer, der deklariert wird, ohne vorher auf etwas zu referenzieren, probleme macht. aber ich befürchte, dass ich prinzipiell einiges noch immer nicht verstanden habe. vorallem, wie ich Pointer vor main, in main, und dynamisch behandle..

    kennt jemand eine gute seite? bzw sieht jemand meine denkfehler?

  • Plantschkuh!
    24
    Plantschkuh!
    Mitglied
    Reaktionen
    163
    Punkte
    6.173
    Beiträge
    1.181
    • 17. Juli 2005 um 15:17
    • #2

    Das ist jetzt nicht konkret auf deine Frage bezogen, aber http://www.eskimo.com/~scs/C-faq/top.html ist recht interessant. Und falls du deinem Buch nicht so ganz traust oder es mit einem anderen ergänzen willst: http://users.powernet.co.uk/eton/clc/cbooks.html

    Zu deinem Code: Es ist nicht gerade hilfreich, wenn du unkompilierbaren Code postest. Etwas wie struct object p {...}; kann es in C zum Beispiel nicht geben. Du meinst vielleicht

    Code
    struct object /* Definition des Typs "struct object" */
    {
        ...
    };
    
    
    struct object p; /* Deklaration des Objekts p vom obigen Typ */


    oder gleich zusammengezogen

    Code
    struct object
    {
        ...
    } p; /* Typdefinition und Deklaration eines Objekts dieses Typs */

    Und zu deiner Frage: Deklarationen sind sowohl außerhalb von Funktionen als auch zu Beginn jedes Blocks erlaubt. Zuweisungen und sonstige Statements sind nur innerhalb von Funktionen erlaubt.

    Eine nackte Deklaration außerhalb einer Funktion deklariert ein Objekt, das über die gesamte Laufzeit des Programms exisitert. Werden solche file-scope-Variablen nicht explizit initialisiert, so initialisiert sie der Compiler mit 0 (vom richtigen Typ, also 0 oder '\0' oder 0.0 oder NULL). Explizit dürfen sie nur mit bestimmten Arten von konstanten Ausdrücken initialisiert werden, deren Wert der Compiler zur Übersetzungszeit berechnen kann.
    Nackte Deklarationen innerhalb von Funktionen deklarieren Variablen, die am Beginn des Blocks erzeugt und am Ende des Blocks zerstört werden. Diese werden nicht implizit initialisiert, explizit dürfen sie auch mit nichtkonstanten Ausdrücken initialisiert werden.

    D.h.

    Code
    int i = 3; /* Deklaration mit konstanter Initialisierung */


    ist sowohl innerhalb als außerhalb von Funktionen erlaubt.

    Code
    int i; /* Deklaration */
    i = 3; /* Zuweisung */


    sowie

    Code
    int i = 3; /* Deklaration mit konstanter Initialisierung */
    int j = i; /* Deklaration mit nichtkonstanter Initialisierung */


    sind nur innerhalb einer Funktion erlaubt.

    *plantsch*

  • Maximilian Rupp 27. Dezember 2024 um 12:06

    Hat das Thema aus dem Forum Programmieren nach Entwicklung verschoben.

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!

Benutzerkonto erstellen Anmelden

Benutzer online in diesem Thema

  • 1 Besucher

Rechtliches

Impressum

Datenschutzerklärung