Kaufmanns Und sowie Sternchen (& *)

[Cfrustfrust]

Hallo zusammen,

ich hoffe ich poste grade in den richtigen Thread...aber klingt erstmal korrekt.

Ich habe ein Problem mit den zwei Steuerzeichen aus dem Titel. Da je nach Kontext diese etwas anderes machen.
Mal abgesehen von der mathematischen operations Funktion, gibt es ja noch Referenzen, Zeiger (Pointer meint hoffentlich das gleiche), angabe der Speicher Adresse.
Und und und.

Ich stolpere grade etwas an folgender Funktion:

int deKlasse::eineFunktion(const char* myChar)

Verstehe ich es richtig, dass hier ein Pointer verlangt wird, ich als bei der Übergabe eine Speicheradresse übergeben muss?
Ich habe nämlich versucht der Funktion folgendes zu übergeben:

myInterger = eineFunktion(&overGivenDoneChar)

manchmal ist das &, bzw. das * am Variablennamen manchmal am Typen.

Ich würde mich auf eine Erklärung dies bezüglich freuen.

Gruß
Sebi

[Tobiking2]

Du bist schon auf dem richtigen Weg. Im Zusammenhang mit einem Typ steht das * für einen Pointer und das & für eine Referenz. Im Bezug auf eine Variable ist * die Dereferenzierung (Adresse -> Inhalt der Adresse) und & der Adressoperator (Variable -> Adresse der Variable).

Beim Typ kann man das * beliebig setzten, bei der Deklaration mehrerer Variablen gibt es aber einen Sonderfall:

char* a; // a ist vom Typ char*
char *b; // b ist ebenfalls vom Typ char*

// aber
char* c,d; // c ist vom Typ char* d ist char

// Deswegen schreibt man häufig lieber
char *e, *f; // e und f ist vom Typ char*

[out]

& kommt öfters vor.

Bei einer Initialisierung bedeutet es, du erstellst eine Referenz. int& ref = variable
Vor einer Variable bedeutet es, du willst die Adresse der Variablen. eineFunktion(&overGivenDoneChar)
Zwischen zwei Variablen bedeutet es, du machst eine UND Verknüpfung. varialbe_1 && variable_2

[Torsten Robitzki]

Richtig, wenn overGivenDoneChar ein char ist, dann ist &overGivenDoneChar ein char*. Das const in der Funktionssignatur gibt an, dass myChar ein Zeiger auf ein konstanten Char ist.

const char* hat meistens eine besondere Bedeutung, die Du eigentlich in der Dokumentation zur Funktion finden solltest. Im Prinzip bedeutet die Parameter-Signatur: "gibt mir ein Zeichen, wenn Du eins hast". Die Optionalität wird durch den Zeiger, der nullptr sein kann, ausgedrückt.

In der Regel ist ein const char* aber als Zeiger auf das erste Zeichen eines arrays von Zeichen zu verstehen, wobei das letzte Zeichen im Array den Wert 0 hat. Das ganze ist ein C-String und wahrscheinlich möchtest Du es in Deinem Fall mit einem String-Literal aufrufen:

result = eineFunktion("my-Prefix ist doof!");

[EOP]

int x = 7 & 11;
cout << x;

int a = 13;
cout << *&a;