1. Pointeurs de caractères et tableaux de caractères

Pointeur de caractère

La variable pointeur de chaîne elle-même est une variable utilisée pour stocker l'adresse de début d'une chaîne. La chaîne elle-même est stockée dans un espace mémoire contigu commençant à cette adresse de début, et se termine par\0comme fin de chaîne.

char *ps="C Language";

signifie 10 éléments dans la première dimension et 20 éléments dans la seconde, avec des valeurs stockées dans une zone mémoire contiguë, sans pointeurs.

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

ps="C Language"; // ps est l'adresse de début de la chaîne. Utilisez ps++ pour parcourir la chaîne. La chaîne est stockée dans un espace mémoire contigu commençant à ps, et se termine par\0comme fin de chaîne.

Il y a deux points à considérer clairement ici :

1. *a pointe simplement vers un caractère.

Un exemple est le suivant :

Exemple

#include <stdio.h> #include <stdlib.h> int main(void){ char *a= "bcd" ; printf("Afficher le caractère : %c\n", *a); /*Pour afficher un caractère, utilisez "%c"*/ printf("Afficher un caractère : %c\n", *(a+1) ); /*Pour afficher un caractère, utilisez "%c"*/ printf("Afficher une chaîne : %s\n", a); /*Pour afficher une chaîne, utilisez "%s" ; de plus, il ne doit pas y avoir d'astérisque "*" avant a.*/ system("pause"); /*Afin de voir le résultat de sortie*/ }

Le résultat d'exécution est le suivant :

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

2. Si une constante de chaîne apparaît dans une expression, la valeur qu'elle représente est l'adresse du premier caractère de cette constante de chaîne. Ainsi, "hello" représente simplement son adresse. La déclaration d'origine équivaut à la déclaration suivante :

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

Tableau de caractères

Un tableau de caractères est composé de plusieurs éléments de tableau et peut être utilisé pour stocker une chaîne entière. (C'est-à-dire utiliser un tableau de caractères pour stocker une chaîne.)

En C, les chaînes sont traitées comme des tableaux de caractères. (Pas en C++.)

Méthodes d'initialisation d'un tableau de caractères :

1). Un tableau de caractères peut être initialisé avec une constante de chaîne :

char  str[]={"Iamhappy"};

Les accolades peuvent être omises.

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

Remarque: L'affectation globale de tableau ci-dessus ne peut être utilisée que lors de l'initialisation d'un tableau de caractères, et non pour l'affectation à un tableau de caractères. L'affectation à un tableau de caractères ne peut se faire qu'élément par élément.

La méthode d'affectation suivante est incorrecte :

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

Attribuez une valeur à chaque élément d'un tableau de caractères, un par un.

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

En C, il existe deux façons de représenter et de stocker des chaînes de caractères :

(1) Utiliser un tableau de caractères pour stocker une chaîne de caractères

char str[]="IloveChina";

(2) Utiliser un pointeur de caractère pour pointer vers une chaîne de caractères

char *str="IloveChina";

Les deux méthodes de représentation utilisent ce qui suit pour afficher des chaînes de caractères :printf（"%s\n", str);

%sPour afficher une chaîne de caractères, donnez le nom de variable de pointeur de caractère str (pour la première représentation, le nom du tableau de caractères est l'adresse de début du tableau de caractères, ce qui a la même signification que le pointeur dans la seconde). Le système affiche d'abord le caractère qu'il pointe, puis incrémente automatiquement str de 1 pour pointer vers le caractère suivant... et ainsi de suite, jusqu'à ce que le terminateur de chaîne soit rencontré.\0 。

2. Pointeurs de chaînes

string* strPeut être affecté :

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

C'est-à-dire que chaque élément est de type string, ce qui est différent de char*. Cependant, string* peut être remplacé par char** :

string = char*, string* = char**

3. Tableaux de pointeurs (de chaînes)

Exemple

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

ou

#include <stdio.h> #include <string.h> int main() { char *str[] = {"Hello", "C++", "World"}; char **p; pour(p=str; p<str+3; p++) puts(*p); #*pest l'adresse de début de la chaîne, *p[0]est l'adresse du premier caractère de la chaîne.}

Exemple

#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("⟦0⟧"); }

Le résultat est :

Hello,ello,o

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

char *a[]: indique que a est un tableau dont les éléments sont des pointeurs de type char (tous les éléments du tableau sont stockés dans une mémoire contiguë). Le nom du tableau est l'adresse mémoire du premier octet du tableau, et le nom du tableau a représente aussi un pointeur. Ainsi, a ne représente pas le contenu stocké à l'adresse a, mais l'adresse a elle-même.

a+1: représente l'adresse mémoire du deuxième élément de a, donc il ajoute 8 octets. (Parce que les éléments de a sont des pointeurs char, nécessitant 8 octets (adresse mémoire 64 bits).)

*(a+1): indique le contenu du deuxième élément du tableau a (qui est un pointeur char, représenté comme l'adresse de la chaîne "world" dans cet exemple).

*(*(a+1)): indique le contenu (le caractère w) pointé par le contenu (pointeur char) du deuxième élément du tableau a.

char * a[10]: indique que ce tableau peut contenir au maximum 10 éléments (pointeurs de char), ce qui signifie que le tableau occupe 10*8 = 80 octets.

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

quatre

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

int main(int argc, char*argv[])Ceci est un exemple typique d’un nom de tableau (ou tableau de pointeurs) utilisé comme paramètre de fonction, et c’est aussi un tableau de paramètres formels sans taille spécifiée.

Parfois, afin de traiter les éléments d’un tableau dans la fonction appelée, un paramètre formel supplémentaire peut être défini pour transmettre le nombre d’éléments du tableau à traiter. De plus, lorsqu’on utilise un nom de tableau comme paramètre réel, ce ne sont pas les valeurs des éléments du tableau qui sont transmises au paramètre formel, mais l’adresse du premier élément du tableau passé en paramètre réel qui est transmise au tableau du paramètre formel, de sorte que les deux tableaux partagent le même emplacement mémoire. Cela diffère de l’utilisation de variables comme paramètres de fonction.

Vous pouvez consulter des exemples de tableaux utilisés comme paramètres de fonction et de tableaux de pointeurs utilisés comme paramètres formels de la fonction main. Le livre de Tan Haoqiang explique cela de manière très détaillée.

1. Lorsque char [] est utilisé comme paramètre de fonction, cela signifie char *. Lorsqu’il est passé comme paramètre de fonction, il copie en réalité l’adresse du premier élément du tableau.

Donc void test(char a[]) est équivalent à void test(char *a)

 char x[10] ;

Ensuite, appeler test(x) équivaut à affecter l’adresse du premier élément de x au paramètre a.

2. char *a et char a[]

  • Similitude : a est un pointeur pointant vers le type char.
  • Différence : char a[] stocke le contenu sur la pile. char *a stocke le pointeur sur la pile et le contenu dans les constantes.

3. char *a

  • Similarité : dans les deux cas, a est un pointeur à deux niveaux ; *a représente un pointeur à un niveau ; **a représente le contenu stocké en mémoire.
  • Différence : char *a

4. Astuce : le nombre de [] et de * se correspondent. Par exemple, char a[][] a 2 niveaux de pointeurs, équivalent à char **a ; char *a[] est également identique, deux niveaux de pointeurs. En cas de confusion, comptez combien il y a de * et de [], et vous saurez si c'est le contenu ou l'adresse qui est stocké. Par exemple, dans le cas de char a[][] : &a, a, *a sont toutes des adresses, tandis que **a est le contenu.

URL d'origine : https://www.cnblogs.com/cj2014/p/3726380.html