Array
char a [n]; lorsque n est un entier ou une expression entière, ce n'est pas un tableau de longueur variable, sinon le tableau est de longueur variable; (c99) les
tableaux de caractères peuvent être imprimés à la fois au format chaîne.
// Méthode d'affectation: char a [] = " abcde " ; int a [ 10 ] = { 1 , 2 , 3 }; // Ceux sans affectation sont tous 0; int a [] = { 1 , 2 , 3 , 4 , 5 }; // Calculer automatiquement la longueur int a [ 10 ] = {[ 3 ] = 3 , [ 5 ] = 5 , [ 8 ] = 8 }; // Spécifier l'affectation // Tableau à deux dimensions: inta [ 2 ] [ 3 ] = { 1 , 2 , 3 , 4 }; int a [ 2 ] [ 3 ] = {{ 1 , 2 }, { 3 }}; int a [ 2 ] [ 3 ] = {[ 0 ] [ 1 ] = 1 , [ 0 ] [ 2 ] = 2 , [ 1 ] [ 0 ] = 3 }; int a [] [ 3 ] = { 1 , 2 , 3, 4 , 5 , 6 , 7 }; // Vous ne pouvez pas écrire le nombre de lignes, mais le nombre de colonnes doit être écrit
Pointeur
Les variables stockent les données, les pointeurs stockent les adresses;
La mémoire occupée par le pointeur est de 4 octets , contrairement aux variables ( int (4), char (1), float (4), double (8)); [Adresse: & a; Valeur: * a;]
int a = 1 ; int * b = & a ; // Si l'affectation n'est pas une adresse, le pointeur pointe vers l'emplacement spécifié représenté par les données entières // L'espace réservé pour l'adresse est% p
Nom numérique
Il s'agit d'une information d'adresse (le nom du tableau est une constante de pointeur ), et c'est également l'adresse du premier élément du tableau; ainsi [tableau / pointeur] peut également accéder aux éléments à l'aide de [pointeur / tableau].
Les tableaux peuvent uniquement accéder à chaque élément séparément (chaque élément est une valeur l) , pas un tableau entier ; (les noms de fonction ont des propriétés similaires)
// La différence entre le pointeur et le nom du tableau: le pointeur est une lvalue (variable, utilisée pour stocker l'adresse), et le nom du tableau est une constante d'adresse (rvalue); int a, b, c = 0 ; int * p [ 3 ] = { " asdf " , " qwer " , " czxnh " }; // Tableau de pointeurs: un tableau ne stockant que des pointeurs; int (* p) [ 3 ]; // Pointeur de tableau: pointeur sur le tableau (l'unité de déplacement du pointeur Est la taille du tableau) // Lors de l' attribution d'une valeur, attribuez-lui l'adresse du tableau: int (* p) [3] = & nom du tableau unidimensionnel
Pointeurs de tableau et tableaux bidimensionnels
Réseau bidimensionnel
Chaque élément est un tableau unidimensionnel, donc le nom du tableau bidimensionnel est l'adresse du premier tableau un bit;
int array [ 4 ] [ 5 ]; array == array [ 0 ]; * (array + 1 ) == array [ 1 ] == & array [ 1 ] [ 0 ]; // Toutes sont des adresses, ajoutez un * devant La valeur à cet emplacement peut être récupérée // ie: * (* (p + i) + j) == p [i] [j];
Pointeur de tableau
int (* p) [5] = tableau;
Pointeur sur le tableau
L'unité du mouvement du pointeur du tableau est la taille du tableau : * (* (p + i) + j) == p [i] [j];
pointeur void (non typé) et pointeur NULL (kong)
void* p:pointeur non typé, quipeut pointer vers n'importe quel type de données; une conversion de type forcée est requise lors du déréférencement;* (int*) p;
pointeur NULL: ne pointe aucune donnée: [En fait, NULL est une définition de macro: 0; #define NULL ((void*) 0) 0 l'adresse n'est généralement pas pointée];
lorsque le pointeur est défini et que l'adresse n'est pas connue, vous pouvez pointer vers NULL [int* p = NULL; 】
Pointeur secondaire
Stockez l'adresse du pointeur; [Le déréférencement à un niveau n'est que l'adresse d'un pointeur ] Étant donné que le pointeur de
deuxième niveau pointe vers le pointeur, l'unité du mouvement du pointeur de deuxième niveau est la taille du pointeur (4 octets)
int ** p1, (* p2) [ 4 ]; // p1 est le pointeur de deuxième niveau, p2 est le pointeur de tableau; * (p1 + 1 ) - * p1 = 4 ; // Étant donné que le pointeur de deuxième niveau pointe vers le pointeur int, la plage est 4 * (p2 + 1 ) - * p2 = 16 ; // Étant donné que ce pointeur de tableau pointe vers un tableau int de longueur 4, la plage est 16
Remarque: Comme mentionné ci-dessus, lorsqu'un pointeur de tableau pointe vers un tableau, il y a * (* (p2 + i) + j) == tableau [i] [j]; le pointeur de deuxième niveau n'a pas cette propriété.
Constantes et pointeurs
1. Définition de la macro: définissez A 'a'
2. Utilisez le mot-clé const (lecture seule et non écriture): const float pai = 3.14;
Pointeur sur constant
const int * p; // Pointeur sur constant, pointe sur constant. La valeur pointée par l'adresse ne peut pas être modifiée par déréférence; la valeur déréférencée peut être modifiée indirectement en modifiant une constante constante int * const p; // Pointez sur un pointeur constant, pointez sur une variable. Impossible de modifier la valeur de l'adresse pointée par le déréférencement; vous pouvez modifier la valeur de la variable pour modifier indirectement la valeur déréférencée const int * const p; // Un pointeur constant vers une constante; [Un pointeur vers une constante peut également pointer vers une variable]