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


von AVRli (Gast)


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...

von ()(()))()((() (Gast)


Lesenswert?

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

von AVRli (Gast)


Lesenswert?

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

Gruß AVRli...

von Karl H. (kbuchegg)


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

von ()(()))()((() (Gast)


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.
1
char buchstabe='a';
2
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?

von ()(()))()((() (Gast)


Lesenswert?

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

von DirkB (Gast)


Lesenswert?

Der Vergleich ob die Zeichenkette nicht leer ist, sieht so aus:
1
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'.

von holger (Gast)


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.

von AVRli (Gast)


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...

von Rufus Τ. F. (rufus) Benutzerseite


Lesenswert?

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

Etwas variiert sieht das dann so aus:
1
void show_str(char *str_source) 
2
{
3
  if (!str_source) 
4
    return;
5
6
  //--- mach was
7
}

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

1
void show_str(char *str_source) 
2
{
3
  if (!str_source) 
4
    return;
5
6
  if (str_source[0])
7
  {
8
    //--- mach was mit dem nichtleeren String
9
  }
10
  else
11
  {
12
    //--- mach was anderes, der String ist leer
13
  }
14
}

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

von AVRli (Gast)


Lesenswert?

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

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.