En programmation, afin de faciliter le traitement des données, plusieurs variables de même type sont organisées sous une forme ordonnée - appelée tableau.

Un tableau est un espace contigu de variables de même type en mémoire. Tous les membres d'un même tableau sont du même type de données et les adresses de tous les membres en mémoire sont continues.

-- Nous pouvons décomposer un tableau en plusieurs éléments de tableau : ces éléments de tableau peuvent être des types de données de base ou des types construits.

int a[100];  //基本数据类型
struct Stu p[100];    //构造

(Remarque : types de données structurels : type de tableau, type d'énumération enum, type de pointeur, type de référence, structure de structure, union union (également appelée union, union), classe, etc.)

--Selon les différents types d'éléments de tableau, les tableaux peuvent être divisés en : tableaux numériques, tableaux de caractères, tableaux de pointeurs et tableaux de structure.

int a[100] ;    //数值数组
char s[100] ;    //字符数组
char *p[100] ;    //指针数组
struct Peo n[100] ;    //结构数组

Le nombre d'indices d'éléments de tableau est également appelé la dimension. Nous pouvons diviser le tableau en tableau unidimensionnel, tableau bidimensionnel, tableau tridimensionnel selon les différentes dimensions... Nous divisons généralement le tableau unidimensionnel ou plus Un tableau de s'appelle un tableau multidimensionnel.

tableau unidimensionnel

Comment utiliser un tableau unidimensionnel

La définition d'un tableau unidimensionnel inclut les exigences suivantes :

Le nom du tableau respecte les règles d'écriture des identifiants (chiffres, lettres anglaises, traits de soulignement).
Les noms de tableau ne peuvent pas être identiques aux autres noms de variables.
L'expression constante entre crochets [] représente le nombre d'éléments du tableau.

//方括号中的数量是其数组所包含元素，但其下标应该从0开始 。

a[3] 包含 a[0], a[1], a[2] 三个元素

//0， 1， 2分别表示其元素下标 。

Eh bien, vous avez maîtrisé l'utilisation des tableaux unidimensionnels, pratiquons la création et l'affectation des tableaux unidimensionnels suivants.

le code s'affiche comme ci-dessous ;

#include <stdio.h>

int main()
{
	int a[100] ;    //在这里我们定义了一个数组a，a有100个成员，每个成员都是int类型
	//没有a这个变量，a是数组的名字，但不是变量名，它是常量
	
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		a[i] = i; //给数组赋值 让a[0] = 0, a[1] = 1 ... a[i] = i ;
	}

	//遍历数组，输出每个成员的值
	for (i = 0; i < 100; i++)
	{
		printf("%d ", a[i]);
        printf("\n");
	}
	printf("\n");

	return 0;
}

Initialisation d'un tableau unidimensionnel

Nous attribuons des valeurs lors de la définition du tableau, qui s'appelle l'initialisation. Si le tableau global n'est pas initialisé, le compilateur l'assignera initialement à zéro. Cependant, si le tableau local n'est pas initialisé, son contenu sera des valeurs aléatoires.

#include <stdio.h>

int b[5] ;	//定义全局数组 

int main()
{
	int a[5] = { 1, 2, 3, 4, 5 }	;	//定义一个数组并进行初始化 
	int c[5] ;	//定义局部数组
	int d[]	= {1, 2, 3}	;	//如果[]中不定义元素个数，定义时必须初始化 
	int e[5] = { 0 };//所有的成员都设置为0
	
	printf("%d\n", a[0]) ;
	printf("%d\n", b[0]) ;
	printf("%d\n", b[2]) ;
	printf("%d\n", c[0]) ;
	printf("%d\n", c[2]) ;
	
	return 0;
}

résultat de l'opération :

Le résultat de cette opération est une bonne démonstration des connaissances dont nous avons parlé plus haut.

nom du tableau

Un tableau en dehors des crochets est le nom du tableau du tableau, par exemple ; a[10], a est le nom du tableau du tableau. Le nom du tableau est une constante d'adresse, représentant l'adresse du premier élément du tableau.

Dans le cas suivant, nous allons utiliser une fonction, donc ici nous allons la vulgariser pour tout le monde en amont, la fonction sizeof().

sizeof est un mot clé, qui est un opérateur de compilation utilisé pour déterminer la taille en octets d'une variable ou d'un type de données . L'opérateur sizeof peut être utilisé pour obtenir la taille des classes, des structures, des unions et d'autres types de données définis par l'utilisateur.

La syntaxe de sizeof :

sizeof (object) ;

Où objet est le type de données dont nous voulons calculer la taille, ces types de données incluent les classes, les structures, les unions et d'autres types de données définis par l'utilisateur.

Eh bien, après en avoir tant appris, jetons un coup d'œil à cette chaîne de codes.

#include <stdio.h>

int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };	//定义一个数组并初始化所有成员变量 

	printf("%p\n", a) ;		//数组名是一个地址的常量，代表数组中首元素的地址。 
	printf("%p\n", &a[0]) ;	// a和a[0]的地址是相同的 

	int n = sizeof(a) ; 		//数组占用内存的大小，5个int类型，5 * 4  = 20
	int n0 = sizeof(a[0]) ;		//数组第0个元素占用内存大小也就是这个数组中每个元素内存的大小。 

	int i = 0;
	for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)	// sizeof(a) / sizeof(a[0]就是数组中元素个数
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

Résultat de sortie :

Selon les résultats de sortie, nous pouvons confirmer que : le nom du tableau représente l'adresse du premier élément du tableau.

Ce qui apparaît dans le code ( sizeof(a) / sizeof(a[0] ) consiste à diviser la taille du tableau entier par la taille d'un seul élément du tableau pour obtenir les éléments de notre tableau.

Groupe d'enseignement des personnages unidimensionnels

Un tableau de caractères à une dimension est généralement utilisé pour stocker et représenter une chaîne. En langage C, le caractère nul '0' (valeur ASCII 0) est généralement utilisé comme signe de fin de chaîne.

Définition du groupe d'enseignement de caractères unidimensionnels

La définition d'un tableau de caractères à une dimension n'est pas très différente de celle d'un tableau à une dimension, et son format est :

char 数组名[数组大小] ;

Par exemple:

char a[10] ;

Cette instruction définit un tableau de caractères unidimensionnel a d'une taille de 10, qui occupe des espaces variables de 10 caractères et peut stocker une chaîne de caractères d'une longueur maximale de 9 (le 10e caractère est '\0'). Étant donné que chaque variable de caractère n'est pas explicitement affectée à une valeur, chaque variable de caractère a une valeur aléatoire .

Initialisation d'un tableau de caractères à une dimension

On pense que le tableau de caractères peut être initialisé en affectant un seul caractère un par un lors de l'initialisation, ou il peut être initialisé par une chaîne.

1) Affectation caractère par caractère

Lorsque nous attribuons des caractères un par un, les trois situations suivantes peuvent se produire.

a. Lorsque le nombre de caractères est inférieur à la taille de l'espace du tableau

Par exemple:

char a[8] = {'h','e','l','l','o'} ;    //始值个数5小于数组a空间个数8

Cette instruction définit un tableau de caractères unidimensionnel a contenant des variables de caractères 8. Les 5 premières variables de caractères sont explicitement initialisées à 5 caractères tels que 'h', 'e', 'l', 'l' et 'o' Les 3 dernières variables de caractère sont le caractère nul '\0'.

Lorsque le tableau de caractères contient le caractère de fin de chaîne '\0', nous pouvons utiliser la fonction printf et le caractère de contrôle de format %s pour afficher la chaîne dans le tableau de caractères. Parmi eux, le caractère de contrôle de format %s, de l'adresse dans la liste de sortie à la première rencontre de '\0', tous les caractères intermédiaires sont sortis.

printf ("%s”，a) ;

Et lorsque nous initialisons un tableau unidimensionnel, sa taille de première dimension peut être omise.

char a[] = {'h','e','l','l','o'} ;

A ce moment, le formulaire de stockage devient comme ceci :

Pour le moment, \0 n'existe pas dans le tableau, c'est-à-dire que nous ne pouvons pas utiliser %s pour la sortie. Donc char a[8] = {'h','e','l','l','o'} et char a[] = {'h','e','l','l' ,'o'} n'est pas une relation d'équivalence.

b. Lorsque le nombre de caractères est égal à la taille de l'espace du tableau

Par exemple:

char a[5]={'h','e','l','l','o'} ;    //初值个数5等于数组大小5

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

On peut trouver que char a[5]={'h','e','l','l','o'} et char a[] = {'h','e','l' ,'l','o'} devient une relation d'équivalence. De plus, le tableau de caractères ne contient pas la marque de fin de chaîne '\0', vous ne pouvez donc pas utiliser printf("%s", c); pour afficher la chaîne qu'il contient.

Donc, pour ce type de tableau, nous utilisons généralement une boucle for pour générer le tableau de caractères.

int i;
for(i=0;i<5;i++) 
{
    printf ("%c",a[i]) ;
}

c. Lorsque le nombre de caractères est supérieur à la taille de l'espace

Lors de l'initialisation, lorsque le nombre de caractères dépasse la taille de l'espace, une erreur sera signalée lors de la compilation.

char a[4] = {'h','e','l','l','o'}; //初值个数5大于数组大小4

Erreur:

2) Affectation d'initialisation de chaîne

En langage C, une chaîne fait généralement référence à un ensemble de plusieurs caractères incluant le terminateur de chaîne '\0'. La constante de chaîne entre guillemets doubles implique le terminateur de chaîne '\0' par défaut.

char a[15] = {"Hello World"}; //注意该数组大小应足够大 不然会报错

Et lorsque nous initialisons des tableaux de caractères avec des chaînes, les accolades peuvent généralement être supprimées, à savoir :

char a[15] = "Hello World"  ;

Alors la relation d'équivalence de notre énoncé est :

char a[15] = {"Hello World"} ;
//等价于	
char a[15] = "Hello World"  ; 
//等价于
char a[15]= {'H','e','l','l','o',' ','W','o','e','l','d','\0','\0','\0','\0'} ; 
//等价于
char a[15]= {'H','e','l','l','o',' ','W','o','e','l','d','\0'} ;
//等价于
char a[15]= {'H','e','l','l','o',' ','W','o','e','l','d'} ;

Parmi eux, la taille du tableau est de 15 que nous avons spécifié. Le format de stockage est également indiqué dans la figure ci-dessous.

Afin d'éviter le phénomène selon lequel le nombre de caractères dépasse l'espace du tableau, nous omettons généralement la taille de l'espace du tableau unidimensionnel lors de l'utilisation de chaînes pour initialiser le tableau de caractères, à savoir :

char a[] = {"Hello World"} ;

En plus de stocker 11 caractères valides dans la chaîne, le tableau stocke également automatiquement le caractère '\0' à la fin de la chaîne. La taille du tableau est donc de 12. Son format de stockage est le suivant.

Afin d'économiser de l'espace et de faciliter l'écriture pour éviter des erreurs inutiles, lorsque nous utilisons des chaînes pour initialiser des tableaux de caractères, nous omettons généralement sa taille unidimensionnelle.

Une référence à un tableau de caractères unidimensionnel

Chaque élément du tableau de caractères est un caractère, nous pouvons donc utiliser la forme d'indice pour accéder à chaque caractère du tableau.

char a[]="abcd" ;

Un tableau de caractères unidimensionnel a est défini et il est initialisé avec une constante de chaîne. La taille du tableau a est de 5 et les valeurs des 4 premiers éléments sont 'a', 'b', 'c' , 'd' respectivement, et les cinquièmes éléments ont la valeur '\0'. Son format de stockage est le suivant.

Nous pouvons faire référence à chaque élément de ce tableau en utilisant a[i], par exemple :

int i;
for(i=0;c[i]!='\0';i++) //当前i号位置的字符变量只要不是结束符就输出
    printf("%c",a[i]) ;

Parmi eux, la boucle for utilise '\0' comme base de jugement, ce qui peut également éviter la complexité du calcul de la longueur.

Tableau à deux dimensions

Lorsqu'un élément de tableau a deux indices, le tableau est appelé un tableau à deux dimensions. Une structure de données bidimensionnelle peut être considérée comme une structure de données plate avec des lignes et des colonnes.

Comment utiliser un tableau à deux dimensions

La forme générale d'une définition de tableau à deux dimensions est :

类型说明符 数组名[常量表达式1][常量表达式2]

L'expression constante 1 représente la longueur de l'indice dans la première dimension, et l'expression constante 2 représente la longueur de l'indice dans la deuxième dimension.

Ses règles de nommage sont les mêmes que celles des tableaux unidimensionnels. Par exemple:

int a[3][4] ;

La première ligne indique qu'un tableau 3×4 a est défini, c'est-à-dire 3 lignes et 4 colonnes avec un total de 12 éléments. Les noms de ces 12 éléments sont : a[0][0], a[0][1], a[0][2], a[0][3] ; a[1][0], a [ 1][1], un[1][2], un[1][3] ; un[2][0], un[2][1], un[2][2], un[2] ][3] ;

Comme pour le tableau unidimensionnel, les indices du numéro de ligne et du numéro de colonne du tableau bidimensionnel commencent à 0. L'élément a[i][j] représente l'élément à la ligne i+1 et à la colonne j+1. L'élément à l'étendue maximale du tableau int a[m][n] est a[m–1][n–1]. Par conséquent, lorsque nous nous référons quotidiennement à des éléments de tableau, nous devons faire attention à ce que la valeur de l'indice soit comprise dans la plage de la taille de tableau définie.

En langage C, lorsqu'un tableau à deux dimensions est stocké, il est stocké par ligne. Par exemple, le tableau a ci-dessus consiste à stocker d'abord la ligne a[0], puis la ligne a[1] et la ligne a[2]. chaque ligne a quatre éléments, qui sont également stockés séquentiellement de 0 à 3.

Pour un tableau à deux dimensions, il n'est que conceptuellement à deux dimensions : son indice change dans deux directions, donc y accéder nécessite généralement deux indices.

En fait, il n'y a pas de tableau bidimensionnel dans la mémoire. La mémoire matérielle réelle du tableau bidimensionnel est adressée en permanence. C'est-à-dire qu'il n'y a qu'un tableau unidimensionnel dans la mémoire. Son adresse mémoire est toujours continue de la même manière que la méthode de stockage d'un tableau unidimensionnel.

Examinons cette chaîne de code :

Exigences, créez un tableau 3 × 4 et attribuez des valeurs séquentiellement à partir de 1 en fonction de la méthode de stockage du tableau.

#include <stdio.h>

int main()
{
	int a[3][4];	//定义二维数组 
	
	/*
	这个二维数组由三个一维数组组成
	这三个一维数组的数组名分别是 a[0],a[1],a[2] 
	而这个一维数组是 int [4]
	*/ 

	int i = 0;
	int j = 0;
	int num = 0;
	
	for (i = 0; i < 3; i++)		//for循环给数组每个元素赋值
	{
		for (j = 0; j < 4; j++)
		{
			a[i][j] = num++;
		}
	}

	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d	 ", a[i][j]) ;	//输出每个成员的值 
		}
		printf("\n");
	}

	return 0;
}

résultat de l'opération :

Initialisation d'un tableau à deux dimensions

La forme d'initialisation d'un tableau à deux dimensions est :

数据类型 数组名[常量表达式1][常量表达式2] = { 初始化数据 } ;

Nous pouvons initialiser un tableau à deux dimensions avec la méthode suivante.

1) Initialiser par ligne

À l'intérieur de { }, utilisez {} deux fois pour initialiser le tableau en fonction du nombre de lignes. Les {} entre les lignes doivent être séparés par des virgules ; {1, 2, 3, 4} dans le code est l'initialisation du tableau de la première ligne ; {5, 6, 7, 8} est l'initialisation du tableau de la deuxième ligne ; { 9, 10, 11, 12} initialise le tableau pour la troisième ligne.

int a[3][4] = {
   
   {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

2) Initialisation de l'affectation continue

L'affectation continue consiste à affecter les données dans { } à chaque élément du tableau tour à tour. Sa séquence d'attribution est la même que la séquence de stockage du tableau à deux dimensions. Par exemple, l'initialisation du tableau a[3][4] commence à partir de l'élément a[0] row a[0][0] vers l'élément a[0][3] puis a[1] row a[1][ 0 ] élément.... et se termine par a[2][3].

int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

3) Initialisation partielle de l'élément

Lorsque nous attribuons une valeur à un tableau à deux dimensions, nous ne pouvons attribuer des valeurs initiales qu'à certains éléments du tableau, puis les éléments non initialisés sont 0.

int a[3][4] = { 1, 2, 3, 4  } ;
int a[3][4] = {
   
   {1, 2}, {5}, {9}};

La première ligne initialise uniquement la première ligne du tableau à deux dimensions, et le reste des lignes vaut 0.

La deuxième ligne attribue des valeurs aux deux premiers éléments de la première ligne et au premier élément des deuxième et troisième lignes. Les éléments restants sont automatiquement 0.

Les résultats des deux cas ci-dessus après l'initialisation sont :

4) Tous les membres sont initialisés avec 0

Le tableau à deux dimensions est "effacé", c'est-à-dire que chaque élément qu'il contient se voit attribuer une valeur de 0. À ce stade, il n'est pas nécessaire d'attribuer une valeur à chaque élément comme auparavant.

int a[3][4]={0}；

5) La première dimension ne définit pas l'initialisation

Si nous attribuons des valeurs initiales à tous les éléments lors de la définition, nous ne pouvons pas spécifier la longueur de la première dimension, mais la longueur de la deuxième dimension ne peut pas être enregistrée. À ce moment, le système calculera la longueur de la première dimension en fonction du nombre total de données et de la longueur de la deuxième dimension. Mais cette écriture omise est rarement utilisée en raison d'une mauvaise lisibilité.

int a[][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

Ainsi, les méthodes d'initialisation des tableaux à deux dimensions peuvent être résumées comme suit :

    //按行进行初始化 	
    int a[3][4] = {
   
   { 1, 2, 3, 4 },{ 5, 6, 7, 8, },{ 9, 10, 11, 12 }} ;

	//连续赋值初始化
	int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  } ;

	//部分元素初始化
	int a[3][4] = { 1, 2, 3, 4  } ;

	//全员赋0初始化
	int a[3][4] = {0} ;

	//第一维不定义初始化
	int a[][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

nom du tableau

Comme un tableau unidimensionnel, le nom du tableau est une constante d'adresse, représentant l'adresse du premier élément du tableau.

#include <stdio.h>

int main()
{
	//定义了一个二维数组
	int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  } ;

	//数组名为数组首元素地址，二维数组的第0个元素为一维数组
	printf("a = %p\n", a) ;    //输出地址
	printf("a[0] = %p\n", a[0]) ;
	
	//测二维数组所占内存空间
	//sizeof(a) = 3 * 4 * 4 = 48
	printf("sizeof(a) = %d\n", sizeof(a)) ;

	//测第0个元素所占内存空间
	printf("sizeof(a[0]) = %d\n", sizeof(a[0]) ) ;

	//测第0行0列元素所占内存空间
	printf("sizeof(a[0][0]) = %d\n", sizeof(a[0][0])) ;

	return 0;
}

résultat de l'opération :

D'après les résultats en cours, nous pouvons voir que l'adresse du nom de tableau a est également l'adresse de a[0][0] dans le tableau à deux dimensions. Et la mémoire occupée par chaque élément int est de 4, si vous souhaitez mesurer la mémoire occupée par chaque ligne, il vous suffit de saisir un indice.

Nous pouvons donc utiliser le rapport de la taille de la mémoire pour calculer le nombre de lignes et de colonnes du tableau à deux dimensions. L'opération de calcul spécifique est la suivante :

	//求二维数组行数
	printf("i = %d\n", sizeof(a) / sizeof(a[0])) ;

	// 求二维数组列数
	printf("j = %d\n", sizeof(a[0]) / sizeof(a[0][0])) ;

	//求二维数组行*列总数
	printf("n = %d\n", sizeof(a) / sizeof(a[0][0])) ;

Tableau de caractères 2D

Un tableau de caractères à deux dimensions est utilisé pour stocker des chaînes, et chaque ligne d'un tableau de caractères à deux dimensions peut être considérée comme un tableau de caractères à une dimension, c'est-à-dire que chaque ligne d'un tableau de caractères à deux dimensions peut stocker une chaîne.

Définition d'un tableau de caractères à deux dimensions

La définition d'un tableau de caractères à deux dimensions est la même que celle d'un tableau à deux dimensions général, sauf que le type de données char est utilisé pour la définition.

char 数组名[第一维大小][第二维大小];

Par exemple:

char a[3][4] ;

Le tableau de caractères à deux dimensions a comporte 3 lignes et 4 colonnes, et chaque ligne peut stocker une chaîne dont la longueur est inférieure ou égale à 3 (raison : ne pas oublier de laisser une place pour l'identifiant de fin de la chaîne).

Initialisation d'un tableau de caractères à deux dimensions

Il est initialisé à peu près de la même manière qu'un tableau à deux dimensions, et il peut également être initialisé au moment de la définition. En règle générale, chaque ligne d'un tableau à deux dimensions est initialisée avec une chaîne.

char a[2][6] = {"Hello","C++" } ;
char a[][6] = {"Hello","C++"} ;//第二维同样不可省略

//等价于
char a[2][6] = {
   
   {"Hello"},{"C++"} } ;

Dans les trois instructions d'initialisation ci-dessus et dans la relation d'équivalence, la taille de la première dimension du tableau à deux dimensions peut être omise. La structure logique du tableau a est la suivante :

aÉtant donné que chaque chaîne de caractères occupe une ligne distincte dans un tableau de caractères à deux dimensions, vous pouvez utiliser a[n] pour faire référence à la chaîne de caractères de la nième ligne du tableau de caractères à deux dimensions ; vous pouvez également utiliser a[i][ j] pour faire référence à une certaine ligne Une seule chaîne dans la colonne.

Les personnages bidimensionnels enseignent les références de groupe

En utilisation normale, vous pouvez utiliser l'indice de ligne et l'indice de colonne pour faire référence à chaque élément (caractère) dans le tableau de caractères à deux dimensions, par exemple :

printf ("%c",a[1][4]) ;     //输出1行4列元素
scanf ("%c",&a[2][3]) ;     //输入一个字符到2行3列元素中
a[2][0]='B' ;     //把字符赋值给2行0列元素
printf ("%s",a[1]) ;     //c[1]为第2行的数组名（首元素地址）
scanf ("%s",a[2]) ;     //输入字符串到c[2]行，从c[2]行的首地址开始存放

Voici les erreurs que nous rencontrons souvent lors de son utilisation. Ici, je vais vous en énumérer quelques-unes :

a[0][0]="A" ;     //行、列下标表示的为字符型元素，不能使用字符串赋值
printf ("%c",a[2]) ;      //a[2]为第3行的首地址，不是字符元素，故不能用%c

Tableaux multidimensionnels

Nous ne voyons généralement pas beaucoup de tableaux multidimensionnels, il n'y a donc pas d'exigences obligatoires ici. Si vous êtes intéressé, vous pouvez le découvrir.

La définition d'un tableau multidimensionnel est similaire à celle d'un tableau à deux dimensions, et son format grammatical est le suivant :

数组类型修饰符 数组名 [n1][n2]…[nn];

int a[3][4][5] ;	//定义三维数组 
int b[4][6][7][3] ;		//定义四维数组

Ici, nous prenons un tableau tridimensionnel comme exemple :

Le nom du tableau est a, la longueur du tableau est 3, chaque élément du tableau est un tableau à deux dimensions, la longueur de ce tableau à deux dimensions est 4 et chaque élément de ce tableau à deux dimensions est un tableau unidimensionnel , la longueur de ce tableau unidimensionnel est 5 et le type d'élément est int.

#include <stdio.h>

int main()
{
	//定义三维数组 
	int a[3][4][5] = 
		{ { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } } };

	int i, j, k;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			for (k = 0; k < 5; k++)
			{
				printf("%d, ", a[i][j][k]);	//输出 
			}
			printf("\n");
		}
	}
	return 0;
}

fin

d'accord! Il ne reste pas beaucoup de connaissances de base sur les tableaux ici. S'il y a quelque chose que vous ne comprenez pas, vous pouvez laisser un message dans la zone de commentaire ci-dessous. Je répondrai à temps après l'avoir vu. Bien sûr, apprendre ces connaissances sur les tableaux n'est pas assez. Ensuite, je publierai une série de formations pratiques sur les tableaux pour renforcer l'apprentissage des connaissances sur les tableaux dans cet article et renforcer certaines connaissances approfondies. Il n'y a pas beaucoup de points de connaissance là-bas. J'utiliserai certains sujets communs dans les tableaux (ordre inverse , tri, etc.) ), et certaines opérations de code liées aux tableaux vous seront expliquées et le code sera joint pour votre référence. Si vous êtes intéressé, faites attention à moi, je publierai de temps en temps des articles de blog expliquant les connaissances, merci beaucoup.

Tableau [Langage C] (explication détaillée + affichage du code source)

Présentation de la baie

tableau unidimensionnel

Comment utiliser un tableau unidimensionnel

Initialisation d'un tableau unidimensionnel

nom du tableau

Groupe d'enseignement des personnages unidimensionnels

Définition du groupe d'enseignement de caractères unidimensionnels

Initialisation d'un tableau de caractères à une dimension

Une référence à un tableau de caractères unidimensionnel

Tableau à deux dimensions

Comment utiliser un tableau à deux dimensions

Initialisation d'un tableau à deux dimensions

1) Initialiser par ligne

2) Initialisation de l'affectation continue

3) Initialisation partielle de l'élément

4) Tous les membres sont initialisés avec 0

5) La première dimension ne définit pas l'initialisation

nom du tableau

Tableau de caractères 2D

Définition d'un tableau de caractères à deux dimensions

Initialisation d'un tableau de caractères à deux dimensions

Les personnages bidimensionnels enseignent les références de groupe

Tableaux multidimensionnels

fin

Je suppose que tu aimes