1. Zeichenzeiger und Zeichenarrays

Zeichenzeiger

Die Stringzeiger-Variable selbst ist eine Variable, die verwendet wird, um die Startadresse einer Zeichenkette zu speichern. Die Zeichenkette selbst wird in einem zusammenhängenden Speicherbereich gespeichert, der an dieser Startadresse beginnt und mit\0als Ende der Zeichenkette endet.

char *ps="C Language";

bedeutet 10 Elemente in der ersten Dimension und 20 Elemente in der zweiten Dimension, wobei die Werte in einem zusammenhängenden Speicherbereich ohne Zeiger gespeichert werden.

char *ps;  // ps 字符串指针，是指针，是一个变量

ps="C Language"; // ps ist die Startadresse der Zeichenkette. Verwenden Sie ps++, um die Zeichenkette zu durchlaufen. Die Zeichenkette wird in einem zusammenhängenden Speicherbereich gespeichert, der bei ps beginnt, und endet mit\0als Ende der Zeichenkette.

Hier sind zwei Punkte klar zu beachten:

1. *a zeigt einfach auf ein Zeichen.

Ein Beispiel ist wie folgt:

Beispiel

#include <stdio.h> #include <stdlib.h> int main(void){ char *a= "bcd" ; printf("Zeichen ausgeben: %c\n", *a); /*Um ein Zeichen auszugeben, verwenden Sie "%c"*/ printf("Zeichen ausgeben: %c\n", *(a+1) ); /*Um ein Zeichen auszugeben, verwenden Sie "%c"*/ printf("Zeichenkette ausgeben: %s\n", a); /*Um eine Zeichenkette auszugeben, verwenden Sie "%s"; außerdem darf vor a kein Sternchen "*" stehen.*/ system("pause"); /*Um das Ausgabeergebnis zu sehen*/ }

Das Ausführungsergebnis ist wie folgt:

输出字符：b 
输出字符：c 
输出字符串：bcd

2. Wenn eine Zeichenkettenkonstante in einem Ausdruck vorkommt, ist der Wert, den sie repräsentiert, die Adresse des ersten Zeichens dieser Zeichenkettenkonstante. "hello" repräsentiert also lediglich seine Adresse. Die ursprüngliche Deklaration ist äquivalent zur folgenden Deklaration:

char *a;  
a="hello"; /*这里字符串"hello"仅仅代表其第一个字符的地址*/

Zeichenarray

Ein Zeichenarray besteht aus mehreren Array-Elementen und kann verwendet werden, um eine ganze Zeichenkette zu speichern. (Das heißt, verwenden Sie ein Zeichenarray, um eine Zeichenkette zu speichern.)

In C werden Zeichenketten als Zeichenarrays behandelt. (In C++ nicht.)

Methoden zum Initialisieren eines Zeichenarrays:

1). Ein Zeichenarray kann mit einer Zeichenkettenkonstante initialisiert werden:

char  str[]={"Iamhappy"};

Die geschweiften Klammern können weggelassen werden.

char  str[]="Iamhappy";  # 系统自动加入 \0

Hinweis: Die obige Gesamt-Array-Zuweisung kann nur bei der Initialisierung eines Zeichenarrays verwendet werden, nicht für die Zuweisung an ein Zeichenarray. Die Zuweisung an ein Zeichenarray kann nur elementweise erfolgen.

Die folgende Zuweisungsmethode ist falsch:

char str[20];
str="Iamhappy";

Weisen Sie jedem Element eines Zeichenarrays einzeln Werte zu.

char str[10]={'I','','a','m','','h','a','p','p','y'};

In C gibt es zwei Möglichkeiten, Strings darzustellen und zu speichern:

(1) Verwenden Sie ein Zeichenarray, um einen String zu speichern

char str[]="IloveChina";

(2) Verwenden Sie einen Zeichenzeiger, um auf einen String zu zeigen

char *str="IloveChina";

Beide Darstellungsmethoden verwenden Folgendes zum Ausgeben von Strings:printf（"%s\n", str);

%sUm einen String auszugeben, geben Sie den Namen der Zeichenzeigervariable str an (bei der ersten Darstellung ist der Zeichenarrayname die Startadresse des Zeichenarrays und hat dieselbe Bedeutung wie der Zeiger bei der zweiten). Das System gibt zuerst die Zeichendaten aus, auf die er zeigt, und erhöht dann str automatisch um 1, um auf das nächste Zeichen zu zeigen ... und so weiter, bis das String-Abschlusszeichen angetroffen wird.\0 。

2. String-Zeiger

string* strKann zugewiesen werden:

string* str = {"hello", "world"}; 
//  对比与 char *name = "wang" = {'w','a','n','g'}
//  *(str) = "hello", *(str+1) = "world"
//  *(*(str)+1) = 'e'

Das heißt, jedes Element hat den Typ string, was sich von char* unterscheidet. string* kann jedoch durch char** ersetzt werden:

string = char*, string* = char**

3. (String-)Zeigerarrays

Beispiel

#include <stdio.h> void main() { char *str[] = {"Hello", "C++", "World"}; //char (*str)[] = ... int i; for(i=0; i<3; i++) printf("%s\n", str[i]); } // str // str // str

oder

#include <stdio.h> #include <string.h> int main() { char *str[] = {"Hello", "C++", "World"}; char **p; for(p=str; p<str+3; p++) puts(*p); #*pist die Startadresse der Zeichenkette, *p[0]ist die Adresse des ersten Zeichens der Zeichenkette.}

Beispiel

#include<stdio.h> #include<stdlib.h> int main() { char *str[3]={"Hello","C++","World"}; printf("%s,%s,%c",str[0],str[0]+1,*(*(str+2)+1)); system("pause"); }

Das Ergebnis ist:

Hello,ello,o

Format:char* na[N] = {"li", "zh", "li", "zh", "li"};

char *a[]: gibt an, dass a ein Array ist, dessen Elemente Zeiger auf den Typ char sind (alle Elemente im Array werden im zusammenhängenden Speicher abgelegt). Der Array-Name ist die Speicheradresse des ersten Bytes des Arrays, und der Array-Name a repräsentiert ebenfalls einen Zeiger. Daher repräsentiert a nicht den an der Adresse a gespeicherten Inhalt, sondern die Adresse a selbst.

a+1: stellt die Speicheradresse des zweiten Elements von a dar, fügt also 8 Bytes hinzu. (Weil die Elemente von a char-Zeiger sind, die 8 Bytes benötigen (64-Bit-Speicheradresse).)

*(a+1): gibt den Inhalt des zweiten Elements des Arrays a an (das ein char-Zeiger ist, dargestellt als die Adresse der Zeichenkette "world" in diesem Beispiel).

*(*(a+1)): gibt den Inhalt (das Zeichen w) an, auf den durch den Inhalt (char-Zeiger) des zweiten Elements des Arrays a gezeigt wird.

char * a[10]: gibt an, dass dieses Array höchstens 10 Elemente (char-Zeiger) aufnehmen kann, das heißt, das Array belegt 10*8 = 80 Bytes.

#w：        a+1   =>   *(a+1)  =>   *(a+1)[0]
           指针(地址)   指针内容(字符串)      字符

vier

char *argv：理解为字符串
char **argv：理解为字符串指针
char *argv[]：字符串指针数组

int main(int argc, char*argv[])Dies ist ein typisches Beispiel für einen Arraynamen (oder ein Zeigerarray), der als Funktionsparameter verwendet wird, und es ist zugleich ein formales Parameterarray ohne angegebene Größe.

Manchmal kann, um Array-Elemente in der aufgerufenen Funktion zu verarbeiten, ein zusätzlicher formaler Parameter festgelegt werden, um die Anzahl der zu verarbeitenden Array-Elemente zu übergeben. Wenn außerdem ein Arrayname als aktueller Parameter verwendet wird, werden nicht die Werte der Array-Elemente an den formalen Parameter übergeben, sondern die Adresse des ersten Elements des aktuellen Parameterarrays wird an das formale Parameterarray übergeben, sodass beide Arrays dieselbe Speicherstelle gemeinsam nutzen. Dies unterscheidet sich davon, Variablen als Funktionsparameter zu verwenden.

Sie können sich Beispiele für Arrays als Funktionsparameter und Zeigerarrays als formale Parameter der main-Funktion ansehen. Das Buch von Tan Haoqiang erklärt dies sehr ausführlich.

1. Wenn char [] als Funktionsparameter verwendet wird, bedeutet es char *. Bei der Übergabe als Funktionsparameter wird tatsächlich die Adresse des ersten Elements des Arrays kopiert.

Also ist void test(char a[]) äquivalent zu void test(char *a)

 char x[10] ;

Dann ist der Aufruf test(x) äquivalent dazu, dem Parameter a die Adresse des ersten Elements von x zuzuweisen.

2. char *a und char a[]

  • Ähnlichkeit: a ist ein Zeiger, der auf den Typ char zeigt.
  • Unterschied: char a[] speichert den Inhalt auf dem Stack. char *a speichert den Zeiger auf dem Stack und den Inhalt in Konstanten.

3. char *a

  • Ähnlichkeit: a ist in beiden Fällen ein zweistufiger Zeiger; *a stellt einen einstufigen Zeiger dar; **a stellt den im Speicher gespeicherten Inhalt dar.
  • Unterschied: char *a

4. Tipp: Die Anzahl von [] und * entspricht sich. Zum Beispiel hat char a[][] 2 Zeigerstufen, äquivalent zu char **a; char *a[] ist ebenfalls dasselbe, zwei Zeigerstufen. Wenn Sie verwirrt sind, zählen Sie, wie viele * und [] vorhanden sind, und Sie wissen, ob Inhalt oder Adresse gespeichert wird. Zum Beispiel sind im Fall von char a[][]: &a, a, *a alle Adressen, während **a Inhalt ist.

Original-URL: https://www.cnblogs.com/cj2014/p/3726380.html