Gruß

Zeiger sind auf unterster Ebene einer der Gründe warum C/C++ so flott ist.

Wo ist denn da der Zusammenhang? Jede halbwegs brauchbare Sprache kennt Zeiger, sei es offen oder versteckt, sonst könnte man gar keine komplexen Programme schreiben. Auch als "langsam" gebrandmarkte Sprachen, wie Java. Gerade Java, wo fast alles über Pointer geht; sie werden dort bloß anders genannt.

ALs ich vor Jahren mich am Zeigerkapitel versucht habe, habe ich lange Zeit immer nur Bahnhof verstanden und wusste nicht so recht wo mir der Kopf steht. (Anmerkung: Ich kam damals von Java)

Technisch gesehen sind Referenzen, Referenzvariablen(wie in Java) und Zeiger bis auf etwas Syntaxzucker das gleiche.

Aber während Java so aussieht (für Anfänger), als ob es keine Zeiger gibt (man merkt das ja wirklich nur beim Call-By-Value, wenn man die eigentliche Referenzvariable neu belegen will) und sich auch so anfühlt, ist die C(++) dann doch weit komplexer. Und spätestens wenn es dann auch um Ressourcenverwaltung geht denkt sich jeder Anfänger doch wahrscheinlich, dass Zeiger etwas unheimlich magisches und komplexes sind.

So jedenfalls fühlte es sich für mich an.

int main(){
    int i=99;
    int *ip;
    ip=&i;
    std::cout << *ip;
    return 0;
}

Wieso

ip=&i;

und nicht

*ip=&i;

?

An dem Adressoperator (&) merkst du, dass du es mit einer Adresse zu tun hast.

ip = &i;
*ip = 100;

std::cout << i << '\n';

schreiben, und würdest als Ausgabe 100 bekommen. Hier zeigt dann ip auf i, und *ip ist i.

char r='u';
    void *i;
    i=&r;
    std::cout << *i;

Warum geht das nicht?
Soweit ich weiß, ist der Zeiger doch auf ein Unbekannten Typ, und so sollte es gehen.

@Skym0sh0: Ja, aber der Grund, warum C und C++ schnell sind, ist ein ganz anderer.

Ja da hast du recht.
Ich merk grad, dass ich etwas um die Ecke, bzw. vorschnell gedacht habe:
Einer der Gründe, warum man mit C/C++ mehr Speed rausholen kann ist, dass man sich selber um Speicherallokation bzw. Deallokationen kümmern kann. Wenn man da Dinge weiss, wie Speicher wann und in welcher Menge gebraucht wird, kann man schön optimieren.
Mein Gedanke war, dass dabei ja mehr oder weniger viel Zeiger gebraucht werden. Daher meine ursprüngliche Aussage.

Sorry für die ungenauen Aussagen, das sollte ich echt mal in naher Zukunft ausmerzen. -.-'

char *cp; // Zeiger auf char
    void *vp; // Zeiger auf void
    vp = cp;

Das geht, aber ich kann cp keinen Wert wie z.B. "u" zuweisen.
Wieso nicht? :I

Geht doch ?
Mal davon abgesehen dass cp nirgendwohin zeigt...

int ∗ip = &i;//SO weise ich dem Zeiger eine neue Adresse zu?
∗ip = 8;//So weise ich der Adresse einen neuen Wert zu?

Wenn das der Code war, ja zu deiner Frage.

int i1, i2;

int* pointer; // definiert einen pointer auf integer
int* pointer = &i1; // definiert einen pointer auf integer, und weißt ihm die addresse von i1 zu

//wenn du pointer schreibst greifst du auf die Adresse zu:
pointer = &i2; //Weist pointer die Adresse von i2 zu
std::cout << pointer; // gibt die adresse aus

//wenn du *pointer schreibst gibst du den Wert aus auf den pointer zeigt
*pointer = 42; //der wert ist jetzt 42
std::cout << *pointer; //gibt 42 aus.

Das Sternchen sorgt dafür dass der Pointer dereferenziert wird. Außer bei der Definition des Pointers, das ist vielleicht etwas verwirrend.

Das geht, aber ich kann cp keinen Wert wie z.B. "u" zuweisen.
Wieso nicht? :I

Vorsicht! "u" ist ein Stringliteral und somit const char* .
Das ist etwas anderes als das Zeichen 'u'.

Es geht

cp = "u";
//oder 
*cp = 'u'; // Hier muss cp aber auf gültigen Speicher zeigen.

c = u8"u";

Je nach Typ von c gehen auch

c = u"u";

c = U"U";

c = L"L";