Zeiger

Hallo,

ich lehrne nun für einen Test und es gibt da ein paar fragen von alten klasuren die ich nicht verstehe. Kann jemanden vielleicht mir ein bisschen erklären versuchen?

int a=1, b=2;
char c[4];
char s

Welche Anweisungen sind in dem Bsp erlaubt.
A int* p = &b;
B int* r = &a;
C int* q = a;
D char* z = c;
E s = *(c + 3);

Das ist im Prinzip alles klar. Ich frag mich aber warum ist C nicht möglich? Soll es nicht ein & vor a geben?

DAnn gibts einen Ausdruck dass die Referenzparameter weniger Speicherlpatz als die Wertparameter brauchen. Warum? Wie kann man da überprüffen?

int a[5]={5,3,1,15,6};
int* x = a+2;

warum wäre da x+=1 gültig???

========================================

int x[3] = {1,2,3};
int *y = x; //(1)
*y = x[0]; //(2)
cout << *x; //(3)

Welche Aussagen sind wahr?
A Das Programm gibt 2 aus.
B x[2] entspricht *(x+2).
C Anweisung (1) ist nicht
zulässig.
D Das Programm gibt 1 aus.
E Anweisung (2) ist
zulässig.

da verstehe ich die E und D nicht. Warum sind die auch Wahr?

Und das beste kommt aber bei dem da:

#include<iostream.h>
void max(int *x, int y){
if (y > 0){
*x = *x – 1;
max(x, y-1);
cout << *x << y;
}
}
int main(){
int i = 6;
max(&i, 2);
return 0;
}
Notieren Sie die Ausgabe:

========================================
UNd zum Schluss:

int b[5]={12,8,4,1,6};
int* y = b+3;

Welche Ausdrücke sind ausgehend
von dieser Situation erlaubt?
A y -= 2;
B *y = b[4];
C cout << *y + 6;
D cout << *(y + 1);

terraner

jniordi schrieb:

Welche Anweisungen sind in dem Bsp erlaubt.
A int* p = &b;
B int* r = &a;
C int* q = a;
D char* z = c;
E s = *(c + 3);

Das ist im Prinzip alles klar. Ich frag mich aber warum ist C nicht möglich? Soll es nicht ein & vor a geben?

Ja

DAnn gibts einen Ausdruck dass die Referenzparameter weniger Speicherlpatz als die Wertparameter brauchen. Warum? Wie kann man da überprüffen?

Weil eben eine Referenz, also mehr oder weniger Zeiger, auf das Objekt übergeben wird und keine Kopie erstellt wird.
Überprüfen könnte man mit "ps"(unix/linux) oder dem taskmanager. ansonsten könnte man bei jedem ctor aufruf sich noch eine nachricht ausgeben lassen (std::clog).

int a[5]={5,3,1,15,6};
int* x = a+2;
warum wäre da x+=1 gültig???
[/cpp]

weil das array 5 elemente hat, der zeiger aber erst auf das dritte zeigt.

int x[3] = {1,2,3};
int *y = x; //(1)
*y = x[0]; //(2)
cout << *x; //(3)
Welche Aussagen sind wahr?
A Das Programm gibt 2 aus.
B x[2] entspricht *(x+2).
C Anweisung (1) ist nicht
zulässig.
D Das Programm gibt 1 aus.
E Anweisung (2) ist
zulässig.

A falsch
B wahr
C falsch
D wahr, weil (2) eine selbstzuweisung ist
E wahr, weil x und y auf gültige speicherbereich zeigen, allerdings auf den selben

Und das beste kommt aber bei dem da:

#include<iostream> // ohne .h!
void max(int *x, int y)
{
    if (y > 0)
    {
        //*x = *x – 1;
        *x -= 1;
        max(x, y-1);
        std::cout << *x << y;
    }
}

int main()
{
    int i = 6;
    max(&i, 2);
 return 0;
}

Notieren Sie die Ausgabe: 4142?

int b[5]={12,8,4,1,6};
int* y = b+3;
Welche Ausdrücke sind ausgehend
von dieser Situation erlaubt?
A y -= 2;
B *y = b[4];
C cout << *y + 6;
D cout << *(y + 1);

A ja
B ja
C "erlaubt": ja, erzeugt aber undefiniertes verhalten, wer es genau wissen will
D ja

nächstes mal bitte einfach selbst mal die programme kompilieren.

mfg