3. Sehr komplizierte Variablendeklarationen - HILFE!

Sehr komplizierte Variablendeklarationen - HILFE!

  • P

    thomassteiner schrieb:

    1. p ist ein Zeiger auf einen konstanten double. Der Zeiger wird mit 0 initialisiert.
    mein vorschlag: double const* p = 0;

    Das ist ein konstanter Zeiger, der auf double zeigt.
    //edit: const* is eh Rotz^^

    const double* p = 0;

    so ist das besser

    0
  • D

    Meiner C++-Kenntnis nach ist beides das gleiche.

    0
  • G
     

    int j = 578;

int *p = &j;  //Variabler Zeiger, variables Objekt

const int *p2 = &j;  //Variabler Zeiger, konstantes Objekt
//int const *p2 = &j;  //ebenso: Variabler Zeiger, konstantes Objekt

int * const p3 = &j; //Konstanter Zeiger, variables Objekt

const int * const p4 = &j;  //Konstanter Zeiger, konstantes Objekt
    0
  • V

    Pellaeon schrieb:

    thomassteiner schrieb:

    1. p ist ein Zeiger auf einen konstanten double. Der Zeiger wird mit 0 initialisiert.
    mein vorschlag: double const* p = 0;

    Das ist ein konstanter Zeiger, der auf double zeigt.
    //edit: const* is eh Rotz^^

    const double* p = 0;

    so ist das besser

    nö.
    "p ist ein Zeiger auf einen konstanten double" liest man vom p aus nach außen.
    double const* p
    "p ist ein konstanter Zeiger auf einen double" liest man auch vom p aus nach außen.
    double * const p

    0
  • C
    Mod

    du hast noch probleme mit der deklaration von funktionen und -zeigern.
    die C syntax ist hier sehr eigenwillig, aber wenn man das prinzip verstanden hat, ist es im grunde simpel:
    - es gibt 2 arten von modifikatoren: prä- und postfix (stets bezogen auf den bezeichner, der evtl. fehlen kann) modifikatoren (ganz analog zu operatoren in ausdrücken), postfix-modifikatoren haben stets vorrang vor präfix-modifikatoren
    - präfix: * & const volatile
    - postfix: () []

    also

    int *a

    lies von rechts nach links (immer vom bezeichner weg, zeiger auf int)

    int a[]

    zunächst die postfix-modifikatoren also ein array, dann die linke seite 'von ints'

    int *a[]

    - analog ein array von zeigern auf int
    mit zusätzlichen klammern können wir den vorrang von modfikatoren ändern:

    int (*a)[]

    ist ein zeiger auf ein array von ints

    unterscheiden kannst du diesen fall (klammern benutzt um vorrang zu ändern) von funktionsdeklarationen leicht dadurch, dass hier die klammern den bezeichner umschliessen.

    also

    int a()

    eine funktion, die keine argumente hat und ein int zurückliefert

    int *a()

    eine funktion, die keine argumente hat und einen zeiger auf int zurückliefert

    int (*a)()

    ein zeiger auf eine funktion, die keine argumente hat und ein int zurückliefert

    implizite typdefinitionen für rückgabewerte oder argumente einer funktion schreibst du auf dieselbe weise, nur lässt du einfach den bezeichner weg

    wir nehmen das letzte beispiel, einen zeiger auf eine funktion, die keine argumente hat und ein int zurückliefert und wollen jetzt eine funktion, die einen solchen funktionszeiger zurückliefert:

    also

    int (*a)()

    wir lassen den bezeichner weg:

    int (*)()

    und machen eine funktion daraus, die diesen zeiger zurückgibt:

    int (*)() f()
    0
  • C
    Mod

    hier noch was exotisches:

    volatile X*const& (Y::*[])(Z(&)())const foo()

    🕶

    0
  • G

    thomassteiner schrieb:

    Bitte helft mir 🙂

    Gerne, welche Probleme hast du denn?

    0
  • T

    thx für die antworten erstmal.
    gleich mal umsetzen 😃

    0
  • T

    okay, erstmal danke.

    ich habe folgende ergebnisse:
    1. double const* p = 0;
    2. const double& (* q(char*))(int&);
    3. int (r)() = s;
    4. void     ()() ( t[7])(int&) = {w, x, y, z};

    die drei ersten ausdrücke lassen sich kompilieren.
    der 4. ausdruck liefert aber folgende fehlermeldung:

    error C2059: syntax error : ')'

    wer kann mir weiterhelfen? 😉

    0
  • C
    Mod

    der letzte teil meines postings war unsinn ... eine solche grammatik wäre auch nicht eindeutig. richtig ist:

    int (*a)()

    nun soll a kein einfacher bezeichner sein, sondern selbst eine funktion, also:

    int (*f())()

    diese verschachtelung macht das ganze ziemlich schnell unübersichtlich, zum glück gibt es ja typedefs; und ein C++ programmierer muss sowas gar nicht lesen können 🙂

    0
  • T

    ah perfekt. dann lautet der ausdruck also:

    void* (*(* t[7])(int&))();

    wo liegen bei so einem ausdruck aber basistyp und deklarator?
    ist der basistyp einfach der am weitesten links liegende datentyp und der deklarator der rest?

    in diesem fall also:

    basistyp: void
    deklarator: * (( t[7])(int&))()

    0
Anmelden zum Antworten