proggen.org

#include <stdio.h>

void strturn(char*, char*);

int main()
{
  setbuf(stdout, NULL);
  char  Text1[50], Text2[50];
  puts("Gib einen Text ein:");
  gets(Text1);
  strturn (Text1, Text2);
  printf("Das ist verkehrt:\n%s", Text2);
  
  return 0;
}

void strturn(char *String1, char *String2)
{
  char *Start = String1;
  printf("Start: %s\n", Start);
  while (*String1 != '\0') String1++;
  String1--;
  while (String1 >= Start){
	printf("String1: %s  String2: %s\n",String1, String2);
	*String2++ = *String1--;
  }
  *String2 = '\0';
  printf("String1: %s  String2: %s\n",String1, String2);
}

printf("String1: %s  String2: %s\n",String1, String2);

printf("String1: %s  String2: %s\n",String1, String2);

Gib einen Text ein:
asdfg
Start: asdfg
String1: g String2: ╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠
╠asdfg
String1: fg String2: ╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠
╠asdfg
String1: dfg String2: ╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠
╠asdfg
String1: sdfg String2: ╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠
╠asdfg
String1: asdfg String2: ╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠
╠asdfg
String1: ╠asdfg String2:
Das ist verkehrt:
gfdsa

*String2++ = *String1--;

  *String2 = '\0';
  printf("String1: %s  String2: %s\n",String1, String2);

  strturn (Text1, Text2);

Warum darf ich bei printf()-Funktion nicht *String1 und *String2 schreiben (mit dem Zeigeroperator)? Schließlich will ich ja hier den Inhalt der Speicherstelle anzeigen und nicht die Adresse, worauf der Zeiger zeigt. Wenn ich mit * versuche, stürzt das Programm ab.

Warum sehe ich beim String2 keine richtige Ausgabe, sondern nur irgendwelche Zeichen, aber mit String1 klappt es einwandfrei.

while (String1 >= Start){
   printf("String1: %s  String2: %s\n",String1, String2);
   *String2++ = *String1--;
  }

Wird zuerst String1 dekrementiert, dann String2 inkrementiert und erst dann die Zuweisung gemacht? Verändern String2 und String1 ihre Adressen VOR der Zuweisung, oder erst danach, wenn die Anweisung abgeschlossen ist - also nach Semikolon?

while (String1 >= Start)
{
   *String2 = *String1;
   String2++;
   String--;
}

Warum ist bei der letzten printf()-Funktion die Ausgabe von String2 komplett leer (siehe oben)?

Also warum geht &Text1, &Text2 nicht (mit dem Adressopeartor)? Ich weiß, dass Arrays Zeiger sind, und Zeiger haben 3 Werte: ihre eigene Adresse im Speicher, Adresse auf die sie Zeigen und den Inhalt der Speicherstelle. Und wenn ich an den Parameter ihre eigene Adresse weitergebe, und nicht die Adresse wohin sie zeigen, was passiert dann (also statt funk(Zeiger) -> funk(*Zeiger)?

forumnewbie hat geschrieben:Hallo!

forumnewbie hat geschrieben:PS: Wo/wie kann ich hier einstellen, dass ich C-Code benutze? Damit die Formatierung besser aussieht.

forumnewbie hat geschrieben:@Xin, ich habe bereits 2 Programmierbücher (C und C++) gelesen (auf Deutsch).

forumnewbie hat geschrieben:Das große Problem bei diesen Büchern ist, dass dort ganz einfache Sachen extrem ausführlich erklärt werden, aber sobald es zu wirklich komplexen Sachen kommt, wie Zeiger, Rekursionen (Algorithmen) usw sind die Erklärungen so dürftig und knapp und mit ganz wenigen Beispielen (manchmal nur eins), dass danach noch ganz viele offene Fragen bleiben. Man denkt man versteht es, aber sobald man andere/solche Beispiel wie oben trifft, stößt man auf Schwierigkeiten. Ich werde mir die Tutorials trotzdem durchlesen und mich ggf nochmal hier melden, wenn etwas noch unklar sein sollte.

cloidnerux hat geschrieben:

Wird zuerst String1 dekrementiert, dann String2 inkrementiert und erst dann die Zuweisung gemacht? Verändern String2 und String1 ihre Adressen VOR der Zuweisung, oder erst danach, wenn die Anweisung abgeschlossen ist - also nach Semikolon?

int i = 0, j = 1;

printf("%d\n", i++ + ++j);

int i = 0;

printf("%d\n", i++ + i + 2);

Hier haben wir also einen Identifier eins vom Typ int und einen Identifier vier vom Typ int[4], vier ist also viermal so groß wie eins.

In den eckigen Klammern wird wieder ein Expression des Typs Integer erwartet.

int object = array[ 17 ]
In den eckigen Klammern wird wieder ein Expression des Typs Integer erwartet. Übergeben wird ein Index und dieser muss ja abzählbar sein. Dass es ein Expression ist bedeutet, dass wir eine Konstante, wie in diesem Beispiel 17, angeben können, eine Variable, wie i im Beispiel zuvor oder auch eine Formel beliebiger Länge zur Berechnung des Indexes wird akzeptiert:

Nehmen wir nun an, dass wir ein sehr großes Array haben, dass es einfach zuviel Aufwand macht, es so zu initialisieren. Wir wissen ja bereits, dass sich C um die Initialisierung von Variablen nicht kümmert, also kümmert es sich auch nicht um die Initialisierung von vielen Variablen. Auch hier müssen wir also selbst ran und hierfür bietet sich natürlich eine Schleife an:

Mit sizeof kann man auch die Größe eines Arrays in Arrays bestimmmen.

Wenn man wissen möchte, wie groß ein Array ist, muss man allerdings die Größe des Datentypes mit verrechnen.

for( i = 0; text; i = i + 1 )

Für den Compiler spielt es keine Rolle, ob Du 0 oder '\0' schreibst, in beiden Fällen wird ein char mit 0 beschrieben.

while( text[length] )
length = length + 1;

Die Schleife wird abgebrochen, sobald das Zeichen \0 gefunden wird, weil wir als Rückgabewert beim text[length] kein Zeichen sondern eine Dezimalzahl 0 zurückbekommen, und somit die Abbruchbedingung erfühlt ist. Richtig?
Ich würde diesen Zusammenhang mit der Schleife und Zeichen \0 => dez 0 an dieser Stelle nochmal erwähnen, dh die Logik in den Beispielen an schwierigen Stellen mit 1-2 Sätzen näher erläutern. Für einen Anfänger ist das nicht sofort klar, wenn überhaupt.

Lob: Einzelne Zeichen suchen und austauschen - ein super Beispiel!


So, nun brauche ich eine Pause Hoffe, dass ich bei meinem Feedback kein Blödsinn geschrieben habe - manchmal passiert das, wenn man zu lange auf den Monitor starrt
Was Bücher angeht - da bin ich einer anderen Meinung. Mir haben sie am Anfang trotzdem sehr geholfen - auch wenn sie leider nicht perfekt sind. Tutorials sind im Vergleich zu den Büchern deutlich kürzer - was nicht schlecht sein muss. Tutorials sind meiner Meinung nach für Benutzer mit Grundkenntnissen geeignet, für blutigen Anfänger sind aber Bücher besser - da man dort Sachen am Anfang viel ausführlicher behandelt und mehrmals wiederholt.

Ein Vorschlag: Eure Tutorials könnte man noch besser machen, wenn man nach jedem Tutorial mehrere Aufgaben dazu gibt, die ein Leser selbständig versuchen kann zu lösen. Und natürlich Lösungen dazu wenn man nicht weiterkommt und für den Vergleich.

Und hier finden wir die 0 schon wieder. Und diesmal tritt sie nicht als 0 oder '\0' (Nullbyte) auf, für Zeiger schreibt man NULL. NULL wird komplett groß geschrieben und ist kein Schlüsselwort von C. Um es verwenden zu können, muss man eine Standardbibliothek wie die stdlib oder die stdio einbinden. Auch NULL hat natürlich wieder den Wert 0, aber der Entwickler kann im Quelltext das Wort NULL sofort erkennen und weiß, dass es sich um einen Nullzeiger handelt und nicht um ein Nullbyte:

In der stdlib findet sich auch die Erklärung, was der Rückgabewert EXIT_SUCCESS in C bedeutet. Er sollte von der main()-Funktion zurückgegeben werden, wenn das Programm erfolgreich beendet wurde.

Aus dem Datentyp (char **) wird durch den Dereferenzierungsoperator der „*“ weggenommen: man erhält den Datentyp (char *). Aus dem Datentyp (char *) wird der Datentyp (char).

Wo ist dann der Unterschied? Ein Array mit angegebener Größe stellt Speicher zur Verfügung - ein Pointer nicht.

char * pointer; // Kein eigener Speicher, zeigt irgendwo hin

Konstante Strings

Sie eignen sich also dazu, um bei der Initialisierung eines Arrays in das Array kopiert zu werden, so dass wir dann unser Array verändern können, ...

Wir haben uns vorhin die Adresse wie einen Index in einem Array vorgestellt. Und das trifft es sehr gut, denn ein Array ist für viele Entwickler einfacher zu verstehen, als ein Pointer, doch in Wirklichkeit ist ein Array komplizierter als ein Zeiger.