auf strukturelemente zugreifen

Caligulaminus

Flub schrieb:

Kann man also immer wenn eine Methode eine Zeichenkette als Rückgabewert liefert
char *methode(...
im prototyp und in der implementation schreiben?

Wenn's ein C-String sein soll, kannst Du nicht, Du mußt.

Flub schrieb:

Woher weiß der compiler, das es überhaupt eine Zeichenkette (char-array ist) wenn es laut char *methode, genauso ein zeiger auf einen char sein könnte?

Die Frage ist falsch.
Es ist ein Zeiger auf einen char - Punkt. Du entscheidest, wie Du ihn verwendest.

Eisflamme

Eine Funktion, die einen char* ausgeben soll etc. handelt damit eben ganz besonders:

Sie geht auf das Element, auf welches char* zeigt (also den char), und gibt diesen aus. Jetzt geht die Funktion davon aus, dass an der Speicheradresse direkt nach dem Zeiger wieder ein auszugebendes Zeichen ist und gibt das auch aus. Solange bis \0 kommt.
Man könnte das auch so schreiben:

void output(const char* str)
{    
    if(*str != '\0')
    { 
        do
        {
            std::cout << *str;
        }while(*(++str) != '\0')
    }
}

Braunstein

Man muß hier lediglich beachten, dass char* kein normaler Zeiger ist, sondern dass es hier diverse Sonderbehandlungen (siehe Streams) gibt. Hierbei wird char* im Allgemeinen als Zeichenkette interpretiert und auch so verwendet. Deswegen setzt man char* häufig mit einer Zeichenkette gleich. Siehe auch alle Funktionen aus cstring. Dies ist natürlich eine Altlast aus C.

volkard

Eisflamme schrieb:

Man könnte das auch so schreiben:

void output(const char* str)
{    
    if(*str != '\0')
    { 
        do
        {
            std::cout << *str;
        }while(*(++str) != '\0')
    }
}

Auch bekannt als das komplizierte if/do-Konstrukt.

void output(const char* str)
{    
    while(*str != '\0')
    { 
        std::cout << *str;
        ++str;
    }
}

Eisflamme

Man sehe es mir nach, ich war noch halb am schlafen. ^^

Caligulaminus

Spricht eigentlich irgendetwas gegen

std::cout << *str++;

?

Eisflamme

hm...

volkard

Caligulaminus schrieb:

Spricht eigentlich irgendetwas gegen
std::cout << *str++;
?

Ich verwende eigentlich nie sowas, wenn ich das Auslesen und das Inkrementieren auch auf zwei Zeilen packen kann.
Früher schrieb ich auch mit Spaß Sachen wie

while(!++*d++);//Vaxerzragvreg rvar Ynatmnuy zvg avrqrejregvtfgrz HVag mhrefg.

, viel schlimmer noch, ich konnte nicht anders.

padreigh

volkard schrieb:

while(!++*d++);//Vaxerzragvreg rvar Ynatmnuy zvg avrqrejregvtfgrz HVag mhrefg.
, viel schlimmer noch, ich konnte nicht anders.

LOL - und da weisst du nach nem halben Jahr noch was es tut? Übrigens hast du vergessen das rot13 zu salzen *eg*

Caligulaminus

Argh!

Dann ist hier d ein int(32)* das auf die untere Hälfte eines int(64) zeigt um hinterher nach inkrementierung dieser auf die obere zu zeigen?

Habe ich das richtig verstanden?

~P.S.: Wird man für sowas eigentlich gefeuert, oder ist das eine effektive Jobsicherung?~

volkard

Caligulaminus schrieb:

Dann ist hier d ein int(32)* das auf die untere Hälfte eines int(64) zeigt um hinterher nach inkrementierung dieser auf die obere zu zeigen?

Ja, den Ausdruck haste gelöst, aber das while vergessen. Es seollte nicht auf int64 beschrängt sein, sondern für int32[1000] gehen, das Inkrementieren stoppt, sobald einmal kein Übertrag geschieht, was auch vorher sichergestellt wird. Also das while hast Du nicht beantwortet.

Caligulaminus

Da hakt's noch...

Dann bezöge sich das vordere ++ auf d, das ! aber auf *d.

Bisher war meine Reihenfolge:
- postfix ++ auf *d
- präfix ++ auf d
- und dann !d

Wo liege ich falsch?

volkard

Caligulaminus schrieb:

Wo liege ich falsch?

Vielleicht habe ich Klammern vergessen. Den Code habe ich nicht getestet, das Original ist nicht mehr auf meinen Platten, fürchte ich.
Außerdem war das Original, glaube ich, sogar Dekrementieren, was dem Audruck noch einen ~ verpaßt hat.

volkard

Caligulaminus schrieb:

Bisher war meine Reihenfolge:
- postfix ++ auf *d
- präfix ++ auf d
- und dann !d

Ich dachte
- postfix ++ auf d
- präfix * auf d++
- präfix ++ auf *d++
- und dann präfix ! auf ++*d++

Ein Blick auf http://www.cppreference.com/wiki/language/operator_precedence scheint das auch zu bestätigen. Bin aber nicht sicher, sondern im Moment zu hungrig für sowas.

Caligulaminus

ielleicht habe ich Klammern vergessen. Den Code habe ich nicht getestet...

Ah! Das erklärt dann meine Verwirrung.

Danke für den Zeitvertreib

C.

Caligulaminus

volkard schrieb:

Ich dachte
- postfix ++ auf d
- präfix * auf d++
- präfix ++ auf *d++
- und dann präfix ! auf ++*d++

Ein Blick auf http://www.cppreference.com/wiki/language/operator_precedence scheint das auch zu bestätigen. Bin aber nicht sicher, sondern im Moment zu hungrig für sowas.

Hmm,

postfix ++ bindet zwar stärker als *, wirkt sich aber erst danach aus (postfix ++ eben).
Sonst würde doch die ganze Logik in deinem Konstrukt (erst referenziertes int inkrementieren...) platzen.

Oder übersehe ich da was?

Naja. Wie auch immer...

Guten Appetit. Ich werde jetzt auch erstmal essen.