Stringzeiger in C
Zugriff auf String über Zeiger
Zeichenzeiger:
- String wird in einem Char -Array gespeichert.
- Char s [10] = "Computer",
- Zeichenzeiger kann auf Char Block verweisen.
- Char *p; p = & s [0], p+1 = 1001, es repräsentiert die Adresse des nächsten Blocks.
*(p+i) = s []
Erläuterung
Nehmen wir im obigen Diagramm an, wir zeichnen einen Zeiger, der ein Zeichen im Typ ist, und deklarieren eine Zeichenfolge, deren Basisadresse 1001 ist. Die Adresse des nächsten Blocks beträgt also 1002. Da jeder Zeichenstypwert 1 Byte im Speicher enthält, wenn die Basisadresse der 1st Block ist 1001, daher muss die Adresse des nächsten Blocks 1002 und so weiter sein. Jetzt hält Zeiger P die Adresse des 1st Block bedeutet die Basisadresse dieser bestimmten Zeichenfolge. Es bedeutet, dass der Wert eines Zeigers 1001 ist. Über diese Basisadresse können wir leicht auf alle Elemente der Zeichenfolge zugreifen.
Stringkonstante
- String literal = String Constant // String
- Printf ("computer"); [was wir in „“, die als Zeichenfolge konstant oder buchstäblich oder Zeichenfolge bezeichnet werden]
- Char S [10] = "Computer";
- Printf (s); Nur Schreiben bedeutet, dass es die Adresse des ersten Blocks des Arrays [] darstellt. Es bedeutet, dass wir hier 1000As eine Adresse des ersten Blocks von Array S [] übergeben.
- Strlen (s); Wir übergeben die Adresse des ersten Blocks von Arrays [].
- Strlen (& s [0]) = strlen (s) = strlen ("computer");
Beispiel 1
In diesem Beispiel können wir den Zeiger durchsehen, dass wir die Gesamtlänge der Zeichenfolge berechnen können.
#enthaltenint Länge (char *p)
int count = 0;
while ( *p != '\ 0')
zählen ++;
P ++;
Rückgabezahl;
int main ()
Char Str [100]; // eine Zeichenfolge deklarieren.
int l;
printf ("\ n geben eine Zeichenfolge ein:");
bekommt (str);
L = Länge (str); // Länge der Zeichenfolge.
printf ("\ n die Länge der angegebenen Zeichenfolge: %d \ n", l);
Rückkehr 0;
Ausgang
Erläuterung
Hier definieren wir einen Funktionsnamen Länge (). In dieser Funktion verwenden wir eine Weile Schleife, in der ein Zustand angegeben ist, dass die Schleife erst dann beendet wird, bis der Zeiger *P kann auf alle Elemente der Zeichenfolge zugreifen. In der Funktion main () deklarieren wir eine Zeichenfolge namens Str [] für eine Zeichenfolge vom Benutzer. Jetzt übergeben wir die Zeichenfolge in der Klammung der Länge () -Funktion, um die Länge der Zeichenfolge zu berechnen.
Beispiel-2
Hier werden wir den Zeiger durchsehen, den wir eine Zeichenfolge umkehren können.
#enthaltenvoid reverse (char [], int, int);
int main ()
Char Str [100], Temp; // eine Zeichenfolge deklarieren.
int i, j, len;
printf ("\ n Bitte geben Sie eine Zeichenfolge ein:");
bekommt (str);
len = strlen (str);
reverse (str, 0, len - 1); // die Zeichenfolge umkehren.
printf ("\ n String nach Umkehr = %s \ n", str);
Rückkehr 0;
void reverse (char st [], int i, int len)
Char Temp;
temp = str [i];
Str [i] = str [len - i];
Str [len - i] = temp;
if (i == len/2)
zurückkehren ;
reverse (str, i + 1, len);
Ausgang
Erläuterung
Hier in der Hauptfunktion () deklarieren wir eine Zeichenfolge namens Str [] und nehmen den Benutzer eine Zeichenfolge mit Hilfe der Get () -Funktion, außer dass wir eine Funktion namens definieren umkehren () Um die Zeichenfolge durch einen Zeiger umzukehren, der auf die Werte von STR [] zugreifen kann.
Beispiel-3
Hier werden wir den Zeiger durchsehen, den wir eine Zeichenfolge kopieren können.
#enthalten/ * Funktionsprototyp *//
Void Copy (char S2 [30], char S1 [30]);
/* Hauptfunktion */
int main ()
Char S1 [30], S2 [30];
int i;
printf ("Zeichenfolge eingeben: \ n");
bekommt (s1);
Kopie (S2, S1);
printf ("Kopierte Zeichenfolge ist: %s \ n", s2);
Rückkehr 0;
/* Funktionsdefinition*//
Hohlraumkopie (char S2 [30], Char S1 [30])
int i;
für (i = 0; S1 [i] != '\ 0'; i ++)
S2 [i] = S1 [i];
S2 [i] = '\ 0';
Ausgang
Erläuterung
Hier in der Hauptfunktion () deklarieren wir zwei Zeichenfolgen mit dem Namen S1 [] und S2 [] und nehmen den Benutzer mit Hilfe der Get () -Funktion in der String S1 [] eine Zeichenfolge ab. Außer dass wir eine Funktion namens definieren Kopieren () So kopieren Sie die Zeichenfolge von S1 [] in Zeichenfolge S2 [] über einen Zeiger, der auf die Werte von String S1 [] zugreifen kann.
Beispiel-4
Hier werden wir den Zeiger durchsehen, dass wir eine Zeichenfolge mit einer anderen Zeichenfolge vergleichen können.
#enthalten// Funktion, die die beiden Zeichenfolge vergleicht
void Compowrings (char* x, char* y)
int flag = 0;
// eine Schleife bis zum Ende wiederholen
// von beiden Saiten
while (*x != '\ 0' || *y != '\ 0')
if ( *x == *y)
x ++;
y ++;
// Wenn zwei Zeichen nicht gleich sind
// Den Unterschied drucken und beenden
else if (( *x == '\ 0' && *y != '\ 0')
|| (*X != '\ 0' && *y == '\ 0')
|| *X != *y)
Flag = 1;
printf ("ungleiche Zeichenfolgen \ n");
brechen ;
// Wenn zwei Saiten genau gleich sind
if (Flag == 0)
printf ("Gleiche Zeichenfolgen \ n");
// Treibercode
int main ()
// gegebene Saiten S1 und S2
Char S1 [20] = "Python";
char S2 [20] = "DSA";
// Funktionsaufruf
Vergleichs (S1, S2);
Rückkehr 0;
Ausgang
Erläuterung
Hier in der Hauptfunktion () deklarieren wir zwei Zeichenfolgen mit dem Namen S1 [] und S2 []. In S1 [] weisen wir einen namens Wert zu “Python" und in S2 [] benannt „DSA. “ Außer dass wir eine Funktion namens definieren vergleichen () So vergleichen Sie die Zeichenfolge von S1 [] und S2 [] über Zeiger, der auf die Werte von String S1 [] und String S2 [] zugreifen kann, um beide Zeichenfolgen miteinander zu vergleichen. Da sind hier zwei Saiten unterschiedlich, so dass die Ausgabe der Zeichenfolge eine ist ungleiche Zeichenfolge.
Abschluss
In diesem Thema haben wir alle Aspekte des Stringzeigers sehr ernst behandelt, um das Konzept des Stringzeiger. Es ist sehr verständlich, dass wir durch einen Zeiger leicht auf den gesamten Index der Zeichenfolge zugreifen können.