mikrocontroller.net

Forum: Compiler & IDEs CHAR Zeiger auf den Wert NULL abfragen, geht das so?


Autor: AVRli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich wollte einer Funktion eine Zeichenkette übergeben und nur wenn der 
Zeiger eben nicht NULL ist soll die Funktion anlaufen.


void show_str(char *str_source) {
  if (str_source != NULL) {
    //--- mach was
  }
}


Ist die Zeichenkette leer dann soll die Verarbeitung dennoch starten...
Der Vergleich würde aber dann nicht funktionieren, kann man der Wert des 
Zeigers "abfragen"?

Gruß AVRli...

Autor: ()(()))()((() (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Passt schon. Wenn die Zeichenkette leer ist ist der Pointer nicht NULL, 
sondern das worauf er zeigt.

Autor: AVRli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ja ok, und wie würde man es anstellen wenn man den Wert des Zeigers 
wissen möchte?

Gruß AVRli...

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
AVRli schrieb:
> Ja ok, und wie würde man es anstellen wenn man den Wert des Zeigers
> wissen möchte?

Was meinst du?
Den Zahlenwert, also die Adresse die in der Zeigervariablen gespeichert 
ist?

Auch ein Pointer ist letztendlich nur eine Variable, die man zb ausgeben 
kann, so wie man auch eine int Variable ausgibt.

Odr willst du wissen, wie du über den Pointer an den Wert kommst, auf 
den der Pointer zeigt?

So wie immer, wenn p ein Pointer ist, dann liefert die Dereferenzierung 
*p den Wert auf den der Pointer zeigt.

  int   i, j;
  int * p;

    p                       i
   +----+                  +-----+
   |    |                  |     |
   +----+                  +-----+

                            j
                           +-----+
                           |     |
                           +-----+


   p = &i;

    p                       i
   +----+                  +-----+
   | o-------------------->|     |
   +----+                  +-----+

                            j
                           +-----+
                           |     |
                           +-----+


    *p = 8;

    p                       i
   +----+                  +-----+
   | o-------------------->|  8  |
   +----+                  +-----+

                            j
                           +-----+
                           |     |
                           +-----+

    p = &j;

    p                       i
   +----+                  +-----+
   | o------------+        |  8  |
   +----+         |        +-----+
                  |
                  |         j
                  |        +-----+
                  +------->|     |
                           +-----+

   *p = 3

    p                       i
   +----+                  +-----+
   | o------------+        |  8  |
   +----+         |        +-----+
                  |
                  |         j
                  |        +-----+
                  +------->|     |
                           +-----+

   p = &i;

    p                       i
   +----+                  +-----+
   | o-------------------->|  8  |
   +----+                  +-----+

                            j
                           +-----+
                           |     |
                           +-----+


   printf( "%d", *p );     -----> Ausgabe 8


 *p:    nimm die Variable p her, verfolg den Pfeil und dort wo du
        landest, das ist *p

Autor: ()(()))()((() (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich glaub dir fehlen Grundlagen... Aber gut, wollen mal nicht gleich 
aufs C-Buch verweisen.
In deinem Beispiel ist str_source ein Pointer, d.h. er enthält die 
Adresse(!) an welcher Stelle im Speicher ein Buchstabe steht.
Um den Buchstaben zu bekommen muss man den Zeiger mit * dereferenzieren.
Also z.B.
char buchstabe='a';
char * ptr=&buchstabe; //ptr die ADRESSE von buchstabe zuweisen
ptr ist ein Pointer und zeigt auf die Adresse an der der Inhalt von 
buchstabe steht, *ptr entspricht also dem Buchstaben 'a'.

Da es um Zeichenketten geht ist die Array-Notation besser: Eine 
Zeichenkette ist ein Array aus Buchstaben welche direkt hintereiander im 
Speicher stehen und durch den Wert 0 (geschrieben '\0') abgeschlossen 
werden.

Wenn wie bei dir ptr ein Pointer auf eine Zeichenkette ist liefert 
*(ptr+i) den i-ten Buchstaben dieser Kette. Diese Schreibweise ist 
vollkommen identisch zu ptr[i] ("syntaktischer Zucker").

Alles klar?

Autor: ()(()))()((() (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
rhaaa, da hab ich mich extra beeilt und dieser Moderator ist schon 
wieder schneller schmoll ;-)

Autor: DirkB (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Der Vergleich ob die Zeichenkette nicht leer ist, sieht so aus:
if (*str_source != 0) { 

Der Inhalt der Speicherstelle auf die str_source zeigt muss ungleich 
Null sein. Denn ein leerer String besteht aus dem Endezeichen '\0'.

Autor: holger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Ist die Zeichenkette leer dann soll die Verarbeitung dennoch starten...

Mal ne ganz blöde Gegenfrage:

Warum? Im String ist nix drin was zu verarbeiten wäre.
Wenn der Pointer auf NULL zeigt dann am besten ganz schnell
weg damit. Wenn der String leer ist, dann ist das erste
Element 0. Kann man auch abfragen und die Routine beenden.

Autor: AVRli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielen Dank,

ich möchte gern den Wert des Zeigers wissen.

holger schrieb:
> Warum? Im String ist nix drin was zu verarbeiten wäre.

Ja es geht darum das die Zeichenkette beim ersten Aufruf unter Umständen 
in der Funktion bearbeitet werden muss. Wenn der Zeiger NULL ist, dann 
ist diese Bearbeitung zu überspringen.

Wenn die Zeichenkette aber keinen Inhalt hat, dann ist der Zeiger wohl > 
NULL und dann soll die funktion komplett ausgeführt werden.

Ich wollte mir eine zusätzliche VAR bei der Übergabe ersparen, man 
könnte da auch einen Schalter einbauen, das wollt ich mir mit dem 
Zeigerwert ersparen.

Gruß AVRli...

Autor: Rufus Τ. Firefly (rufus) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Schön und gut, dann ist Deine im Eingangsposting beschriebene 
Vorgehensweise möglich.

Etwas variiert sieht das dann so aus:
void show_str(char *str_source) 
{
  if (!str_source) 
    return;

  //--- mach was
}

"mach was" kann nun zwischen leeren und nichtleeren Strings 
differenzieren:

void show_str(char *str_source) 
{
  if (!str_source) 
    return;

  if (str_source[0])
  {
    //--- mach was mit dem nichtleeren String
  }
  else
  {
    //--- mach was anderes, der String ist leer
  }
}

Wichtig ist, daß vor der Prüfung auf "leer"/"nichtleer" geprüft wird, 
daß der übergebene Pointer nicht NULL ist.

Autor: AVRli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Damit wäre es dann geklärt! Funktioniert soweit auch!
Besten Dank AVRli...

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.