Pointer incrementieren schlägt fehl?!

[Jan H. (janiiix3)]

Hallo.

Auf nem MEGA32 klappt es, nur auf dem Rechner nicht. Es wird nichts 
angezeigt. Wieso?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */



void ausgabe(char *str){
  
  int x = 0;
  
  *str++ = 'A';
  *str++ = 'B';
  *str++ = 'C';
  
  //str[x++] = 'A';
  //str[x++] = 'B';
  //str[x++] = 'C';
  
  printf(str);
}


int main(int argc, char *argv[]) 
{
  char *buff = (char*)calloc(11,sizeof(char));
  ausgabe(buff);

  return 0;
}

[Peter II (Gast)]

Jan H. schrieb:
> printf(str);

überlege doch mal wo der Zeiger str nach deinen str++ steht?

[Tom (Gast)]

Jan H. schrieb:
> *str++ = 'C';

Tip: Wohin zeigt str nach dieser Zeile?

[Adam P. (adamap)]

Für printf und andere String-Fkt. würde ich einen String auch imemr mit 
'\0' abschliessen.

Würde mich wundern wenn genau der Source aufm µC läuft.
FEHLER beim Copy&Paste ? ;-)

Versuch das:

void ausgabe(char *str){
  
  char *tmp = str;

  *tmp++ = 'A';
  *tmp++ = 'B';
  *tmp++ = 'C';
  *tmp   = '\0';
 
  printf(str);
}

[Sinus T. (micha_micha)]

Denk daran, dass ein String mit /0 abgeschlossen werden muss

[Adam P. (adamap)]

P.S. Entschuldigt bitte, dass ich jetzt den "Ratespaß" vermiest habe :)

[Peter II (Gast)]

Adam P. schrieb:
> Für printf und andere String-Fkt. würde ich einen String auch imemr mit
> '\0' abschliessen.

hat doch

> calloc

Sinus T. schrieb:
> Denk daran, dass ein String mit /0 abgeschlossen werden muss

hat er

[Jan H. (janiiix3)]

Denkfehler. Habs gefunden!

[Reinhold (Gast)]

Tipp am Rande: Bei der Inkrementierungs-Dereferenzierungs-Geschichte 
Klammern setzen. Dann ist auf Anhieb klar was deine Intention war und 
was der Code macht wenn man die C Operator Precedence gerade nicht parat 
hat ;)

[Adam P. (adamap)]

Peter II schrieb:
> hat doch

Ja hast recht, hatte es übersehen.

[Tom (Gast)]

Mit dem Verändern von Parametern innerhalb einer Funktion kann man sich 
wie man hier sieht sehr elegant und effizient selbst hereinlegen.

void ausgabe(char *str)
{
    char* write_cursor = str;
    *write_cursor++ = 'A';
    *write_cursor++ = 'B';
    *write_cursor++ = 'C';
     
    printf(write_cursor);
}

In dieser Version wäre der Fehler offensichtlich gewesen. 'str' ist im 
Hinterkopf als "der String, in den ich schreibe" abgelegt. Wenn man den 
String am Ende der Funktion ausgeben will, liegt 'printf(str)' nahe; 
dass man 'str' vorher verändert hat, hat man an der Stelle leicht schon 
wieder vergessen.

[Peter II (Gast)]

Adam P. schrieb:
> printf(str);

oder ganz böse

printf(str-3);

[Adam P. (adamap)]

Tom schrieb:
> In dieser Version wäre der Fehler offensichtlich gewesen.

Aber wer nutzt ein temp. Arbeitszeiger um etwas zu verändern und 
übergibt printf dann nicht das Original?

Peter II schrieb:
> Adam P. schrieb:
>> printf(str);
>
> oder ganz böse
> printf(str-3);

:-D  Ja, wer drauf steht!

[Adam P. (adamap)]

Jan,
du kannst es aber auch so machen:

void ausgabe(char *str)
{
  str[0] = 'A';
  str[1] = 'B';
  str[2] = 'C';
 
  printf(str);
}

...gibt 1000 Wege.


edit:
Ah, so hattest du es wohl schon mal - jedoch auskommentiert. OK.

[Dr. Sommer (Gast)]

Jan H. schrieb:
> char *buff = (char*)calloc(11,sizeof(char));

sizeof(char) ist per Definition immer 1. Du kannst also einfach 
calloc(11,1) oder noch einfacher malloc(11) schreiben. Der Grund ist, 
dass sizeof die Größe des Typs als Vielfache von der Größe von "char" 
zurückgibt, und "char" ist nunmal genau 1 char groß, also ist es immer 
1. (Siehe z.B. http://en.cppreference.com/w/c/language/sizeof )

Der Cast nach char* ist übrigens in C nicht nötig, nur in C++ - aber da 
würde man onehin lieber "new" nutzen.

[Peter II (Gast)]

Dr. Sommer schrieb:
> Der Cast nach char* ist übrigens in C nicht nötig, nur in C++ - aber da
> würde man onehin lieber "new" nutzen.

bei new müsst man aber wieder die 0 reinschreiben.

[Dr. Sommer (Gast)]

Peter II schrieb:
> bei new müsst man aber wieder die 0 reinschreiben.
Welche 0? Ich hätte jetzt so gesagt in C++:

char *buff = new char [11];

Und eben in C:

char* buff = malloc (11);

[Peter II (Gast)]

Dr. Sommer schrieb:
> Welche 0? Ich hätte jetzt so gesagt in C++:

er hat aber calloc verwenden das initialisiert den Speicher mit 0, das 
macht new und malloc nicht.

[Jan H. (janiiix3)]

Habe das gerade mal ausprobiert.
Da stürzt die .exe ab.

void ausgabe(char *str)
{
    char* write_cursor = str;
    *write_cursor++ = 'A';
    *write_cursor++ = 'B';
    *write_cursor++ = 'C';
     
    printf(write_cursor);
}

int main(int argc, char *argv[]) {
  
  ausgabe("WIRD EH NICHT BENUTZT^^");
  
  return 0;
}

[Adam P. (adamap)]

Peter II schrieb:
> das
> macht new und malloc nicht.

wie ist es mit:

char *buf = new char[11]();

...das macht ein Zero-Memory.

[Adam P. (adamap)]

Jan H. schrieb:
> Habe das gerade mal ausprobiert.
> Da stürzt die .exe ab.

War das jetz nur aus Neugier?

[Peter II (Gast)]

Jan H. schrieb:
> Habe das gerade mal ausprobiert.
> Da stürzt die .exe ab.

ja, weil du versucht einen kontante, die im nicht schreibbaren Speicher 
steht zu überschreiben. Das würde auf einen µC funktionieren, auf den 
meisten PCs nicht mehr.

[Jan H. (janiiix3)]

Peter II schrieb:
> Jan H. schrieb:
>> Habe das gerade mal ausprobiert.
>> Da stürzt die .exe ab.
>
> ja, weil du versucht einen kontante, die im nicht schreibbaren Speicher
> steht zu überschreiben. Das würde auf einen µC funktionieren, auf den
> meisten PCs nicht mehr.

Wenn ich jetzt mit calloc(), den Speicher "freigebe", klappt es!

[Peter II (Gast)]

Jan H. schrieb:
> Wenn ich jetzt mit calloc(), den Speicher "freigebe", klappt es!

mit calloc kann man keinen Speicher freigeben. Keine Ahnung was du 
gemacht hast und was dann klappt.

[Sebastian S. (amateur)]

Es ist doch immer wieder Interessant, wie viele Fehler man in so wenig 
Zeilen machen kann.

Interessant ist auch, dass das ganze auf 'nem Mega32 geklappt haben 
soll.


Da war doch irgendwo eine uralte Schwarte mit den Grundlagen zu "C".

Oder kann es sein, dass man so etwas heute nicht mehr braucht?

Also ich würde sagen man kann den Ansatz: "Learning by doing" auch 
übertreiben.

[Johnny B. (johnnyb)]

Adam P. schrieb:
> Versuch das:
>
>

> void ausgabe(char *str){
> 
>   char *tmp = str;
> 
>   *tmp++ = 'A';
>   *tmp++ = 'B';
>   *tmp++ = 'C';
>   *tmp   = '\0';
> 
>   printf(str);
> }
>

In der Praxis würde ich jeweils noch die Länge des reservierten 
Speichers für die Zeichenkette mitgeben und beachten. Ansonsten kann es 
bei späteren Anpassungen und Unachtsamkeit durch einen selbst oder 
andere Entwickler schnell mal passieren, dass man über den reservierten 
Speicher hinaus schreibt und es dann zu nicht gewolltem Verhalten führen 
kann, welches nur sehr mühsam aufzuspüren ist.

[xxx (Gast)]

Jan H. schrieb:
> *str++ = 'A';

Wie ist denn da die Reihenfolge?
Zuerst pointer erhöhen (str++) dann dereferenzieren (*(str++)) und dann 
'A' zuweisen? Dann würde aber an der ersten übergebenen Adresse nichts 
stehen.

[Adam P. (adamap)]

Johnny B. schrieb:
> In der Praxis würde ich...

Ich habe lediglich seine "fehlerhafte" Fkt. korrigiert, selbst würde ich 
so nicht programmieren.

edit:
Die Fkt. ist ansich schon "sinnfrei", wenn eine Fkt. "ausgabe" heißt, 
dann soll deren Aufgabe die Ausgabe sein und nicht String-Manipulation 
:-D

[Peter II (Gast)]

xxx schrieb:
> Wie ist denn da die Reihenfolge?
> Zuerst pointer erhöhen (str++) dann dereferenzieren (*(str++)) und dann

nein.

str++ ist post Inkrement also nach dem ;

[S. R. (svenska)]

xxx schrieb:
> Jan H. schrieb:
>> *str++ = 'A';
>
> Wie ist denn da die Reihenfolge?

Sinnvoll: Schreibe ein 'A' an *str, dann incrementiere str.

[(prx) A. K. (prx)]

Reinhold schrieb:
> Tipp am Rande: Bei der Inkrementierungs-Dereferenzierungs-Geschichte
> Klammern setzen.

Der Ausdruck *str++ ist derart grundlegend für C, dass ich geradezu 
davon abraten würde, dort Klammern zu setzen. Sondern raten würde, zu 
verstehen, warum das so funktioniert.

An dieser Stelle Klammern zu setzen sorgt eher für Erheiterung 
erfahreneren Publikums als für Verständnis beim Lesen.

Es gibt gute Gründe dafür, solche Seiteneffekt-Operationen abzulehnen, 
unbeschadet des intuitiven oder unintuitiven Vorrangs der Operatoren. 
Aber dann richtig. Also
  *str = 'A'; str += 1;
  *str = 'B'; str += 1;
um Diskussionen zu vermeiden, was bei
  *str++ = *str++ = *str++ = 0;
alles rauskommen kann. ;-)

[Peter II (Gast)]

Reinhold schrieb:
> Tipp am Rande: Bei der Inkrementierungs-Dereferenzierungs-Geschichte
> Klammern setzen. Dann ist auf Anhieb klar was deine Intention war und
> was der Code macht wenn man die C Operator Precedence gerade nicht parat
> hat ;)

wir würdest du denn die Klammern setzen wollen?