Un tableau est la structure de données la plus simple en C qui stocke des données homogènes dans des emplacements mémoire contigus. Si nous voulons créer un Array, nous déclarons le type Data et y donnons des éléments :
#include int main() { int i, arr[5] = {1, 2, 4, 2, 4}; for(i = 0; i <5; i++) { printf('%d ', arr[i]); } < pre> <p> <strong>Output:</strong> </p> <pre> 1 2 4 2 4 </pre> <p>In C, a Character and a String are separate data types, unlike other programming languages like Python. A String is a collection of Characters. Hence, to define a String, we use a Character Array:</p> <pre> #include int main() { char str[8]; printf('Enter a String: '); scanf('%s', &str); printf('%s', str); } </pre> <p> <strong>Output:</strong> </p> <pre> Enter a String: Hello Hello </pre> <p>Now, we want to create an Array of Strings which means we are trying to create an Array of Character Arrays. We have two ways we can do this:</p> <ol class="points"> <li>Using Two-dimensional Arrays</li> <li>Using Pointers</li> </ol> <h3>Using Two-dimensional Arrays:</h3> <p>Creating a String Array is one of the applications of two-dimensional Arrays. To get a picture of the arrangement, observe the below representation:</p> <p>For suppose we want to create an Array of 3 Strings of size 5:</p> <img src="//techcodeview.com/img/c-tutorial/46/an-array-strings-c.webp" alt="An Array of Strings in C"> <p>Every String in a String Array must terminate with a null Character. It is the property of a String in C.</p> <p> <strong>Syntax to create a 2D Array:</strong> </p> <pre> Data_type name[rows][columns] = {{values in row 1}, {values in row 2}…}; </pre> <p> <strong>Syntax to create a String Array:</strong> </p> <pre> char Array[rows][columns] = {'String1', 'String2'...}; </pre> <p> <strong>Now, let us create an example String Array:</strong> </p> <ul> <li>Observe that when we assign the number of rows and columns, we need to consider the Null Character to the length.</li> </ul> <pre> #include int main() { int i; char Array[3][6] = {'Black', 'Blame', 'Block'}; printf('String Array:
'); for(i = 0; i <3; i++) { printf('%s
', array[i]); } return 0; < pre> <p> <strong>Output:</strong> </p> <pre> String Array: Black Blame Block </pre> <ul> <li>char Array[3][6] = {'Black', 'Blame', 'Black'} -> {{'B', 'l', 'a', 'c', 'k', ' '}, {'B', 'l', 'a', 'm', 'e', ' '}, {'B', 'l', 'a', 'c', 'k', ' '}}</li> <li>We cannot directly manipulate the Strings in the Array as a String is an immutable data type. The compiler raises an error:</li> </ul> <pre> char Array[0] = 'Hello'; </pre> <p> <strong>Output:</strong> </p> <pre> [Error] assignment to expression with Array type </pre> <ul> <li>We can use the strcpy() function to copy the value by importing the String header file:</li> </ul> <pre> char Array[3][6] = {'Black', 'Blame', 'Block'}; strcpy(Array[0], 'Hello'); for(i = 0; i <3; i++) { printf('%s
', array[i]); } < pre> <p> <strong>Output:</strong> </p> <pre> String Array: Hello Blame Block </pre> <p> <strong>The Disadvantage of using 2D Arrays:</strong> </p> <p>Suppose we want to store 4 Strings in an Array: {'Java', 'T', 'point', 'JavaTpoint'}. We will store the Strings like this:</p> <img src="//techcodeview.com/img/c-tutorial/46/an-array-strings-c-2.webp" alt="An Array of Strings in C"> <ul> <li>The number of rows will be equal to the number of Strings, but the number of columns will equal the length of the longest String.</li> <li>The memory allocated to all the Strings will be the size of the longest String, causing ' <strong>Memory wastage</strong> '.</li> <li>The orange part in the above representation is the memory wasted.</li> </ul> <h3>Using Pointers:</h3> <p>By using Pointers, we can avoid the Disadvantage of Memory wastage. But how do we do this?</p> <p>We need to create an Array of Pointers pointing to Strings. Hence, we need to create an Array of type ' <strong>char*</strong> '. This way, all the Strings are stored elsewhere in the exactly needed memory, and the Pointers in the Array point to those memory locations causing no memory wastage. More specifically, the Pointers in the Array point to the first Character of the Strings.</p> <p> <strong>Syntax to create an Array of Pointers:</strong> </p> <p>Data Type* name[] = {'Value 1', 'Value 2'…};</p> <p> <strong>Syntax to create an Array of String Pointers:</strong> </p> <p>char* Array[] = {'String 1', 'String 2'…};</p> <p> <strong>Representation:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/46/an-array-strings-c-3.webp" alt="An Array of Strings in C"> <p> <strong>Now, let us create an example String Array:</strong> </p> <pre> #include #include int main() { int i; char* Array[] = {'HI', 'UP', 'AT'}; printf('String Array:
'); for(i = 0; i <3; i++) { printf('%s
', array[i]); } return 0; < pre> <p> <strong>Output:</strong> </p> <pre> String Array: HI UP AT </pre> <h3>Summary:</h3> <p>We cannot create a String Array like a normal one, as a String is an Array of Characters. We have two ways to do this:</p> <p> <strong>1. Using a Two-Dimensional Array:</strong> </p> <p>The Disadvantage of using this way is ' <strong>Memory wastage</strong> ,' as the memory allocated to every String in the Array will be the memory required to store the longest String of the Array.</p> <p> <strong>2. Using Pointers:</strong> </p> <p>Using Pointers, we create a single-dimensional Array of Pointers pointing to Strings. Following this method can eliminate the 'Memory wastage' Disadvantage.</p> <hr></3;></pre></3;></pre></3;></pre></5;> En C, un caractère et une chaîne sont des types de données distincts, contrairement à d'autres langages de programmation comme Python. Une chaîne est une collection de caractères. Ainsi, pour définir une String, nous utilisons un Character Array :
#include int main() { char str[8]; printf('Enter a String: '); scanf('%s', &str); printf('%s', str); } Sortir:
Enter a String: Hello Hello
Maintenant, nous voulons créer un tableau de chaînes, ce qui signifie que nous essayons de créer un tableau de tableaux de caractères. Nous avons deux manières de procéder :
- Utiliser des tableaux bidimensionnels
- Utiliser des pointeurs
Utilisation de tableaux bidimensionnels :
La création d'un tableau de chaînes est l'une des applications des tableaux bidimensionnels. Pour avoir une idée de l'arrangement, observez la représentation ci-dessous :
Supposons que nous voulions créer un tableau de 3 chaînes de taille 5 :
constructeurs en Java
Chaque chaîne d'un tableau de chaînes doit se terminer par un caractère nul. C'est la propriété d'une String en C.
Syntaxe pour créer un tableau 2D :
Data_type name[rows][columns] = {{values in row 1}, {values in row 2}…}; Syntaxe pour créer un tableau de chaînes :
char Array[rows][columns] = {'String1', 'String2'...}; Maintenant, créons un exemple de tableau de chaînes :
variable bash
- Observez que lorsque nous attribuons le nombre de lignes et de colonnes, nous devons prendre en compte le caractère nul à la longueur.
#include int main() { int i; char Array[3][6] = {'Black', 'Blame', 'Block'}; printf('String Array:
'); for(i = 0; i <3; i++) { printf(\'%s
\', array[i]); } return 0; < pre> <p> <strong>Output:</strong> </p> <pre> String Array: Black Blame Block </pre> <ul> <li>char Array[3][6] = {'Black', 'Blame', 'Black'} -> {{'B', 'l', 'a', 'c', 'k', ' '}, {'B', 'l', 'a', 'm', 'e', ' '}, {'B', 'l', 'a', 'c', 'k', ' '}}</li> <li>We cannot directly manipulate the Strings in the Array as a String is an immutable data type. The compiler raises an error:</li> </ul> <pre> char Array[0] = 'Hello'; </pre> <p> <strong>Output:</strong> </p> <pre> [Error] assignment to expression with Array type </pre> <ul> <li>We can use the strcpy() function to copy the value by importing the String header file:</li> </ul> <pre> char Array[3][6] = {'Black', 'Blame', 'Block'}; strcpy(Array[0], 'Hello'); for(i = 0; i <3; i++) { printf(\'%s
\', array[i]); } < pre> <p> <strong>Output:</strong> </p> <pre> String Array: Hello Blame Block </pre> <p> <strong>The Disadvantage of using 2D Arrays:</strong> </p> <p>Suppose we want to store 4 Strings in an Array: {'Java', 'T', 'point', 'JavaTpoint'}. We will store the Strings like this:</p> <img src="//techcodeview.com/img/c-tutorial/46/an-array-strings-c-2.webp" alt="An Array of Strings in C"> <ul> <li>The number of rows will be equal to the number of Strings, but the number of columns will equal the length of the longest String.</li> <li>The memory allocated to all the Strings will be the size of the longest String, causing ' <strong>Memory wastage</strong> '.</li> <li>The orange part in the above representation is the memory wasted.</li> </ul> <h3>Using Pointers:</h3> <p>By using Pointers, we can avoid the Disadvantage of Memory wastage. But how do we do this?</p> <p>We need to create an Array of Pointers pointing to Strings. Hence, we need to create an Array of type ' <strong>char*</strong> '. This way, all the Strings are stored elsewhere in the exactly needed memory, and the Pointers in the Array point to those memory locations causing no memory wastage. More specifically, the Pointers in the Array point to the first Character of the Strings.</p> <p> <strong>Syntax to create an Array of Pointers:</strong> </p> <p>Data Type* name[] = {'Value 1', 'Value 2'…};</p> <p> <strong>Syntax to create an Array of String Pointers:</strong> </p> <p>char* Array[] = {'String 1', 'String 2'…};</p> <p> <strong>Representation:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/46/an-array-strings-c-3.webp" alt="An Array of Strings in C"> <p> <strong>Now, let us create an example String Array:</strong> </p> <pre> #include #include int main() { int i; char* Array[] = {'HI', 'UP', 'AT'}; printf('String Array:
'); for(i = 0; i <3; i++) { printf(\'%s
\', array[i]); } return 0; < pre> <p> <strong>Output:</strong> </p> <pre> String Array: HI UP AT </pre> <h3>Summary:</h3> <p>We cannot create a String Array like a normal one, as a String is an Array of Characters. We have two ways to do this:</p> <p> <strong>1. Using a Two-Dimensional Array:</strong> </p> <p>The Disadvantage of using this way is ' <strong>Memory wastage</strong> ,' as the memory allocated to every String in the Array will be the memory required to store the longest String of the Array.</p> <p> <strong>2. Using Pointers:</strong> </p> <p>Using Pointers, we create a single-dimensional Array of Pointers pointing to Strings. Following this method can eliminate the 'Memory wastage' Disadvantage.</p> <hr></3;></pre></3;></pre></3;> - char Array[3][6] = {'Noir', 'Blame', 'Noir'} -> {{'B', 'l', 'a', 'c', 'k', ' ' }, {'B', 'l', 'a', 'm', 'e', ' '}, {'B', 'l', 'a', 'c', 'k', ' '}}
- Nous ne pouvons pas manipuler directement les chaînes du tableau car une chaîne est un type de données immuable. Le compilateur génère une erreur :
char Array[0] = 'Hello';
Sortir:
[Error] assignment to expression with Array type
- Nous pouvons utiliser la fonction strcpy() pour copier la valeur en important le fichier d'en-tête String :
char Array[3][6] = {'Black', 'Blame', 'Block'}; strcpy(Array[0], 'Hello'); for(i = 0; i <3; i++) { printf(\'%s
\', array[i]); } < pre> <p> <strong>Output:</strong> </p> <pre> String Array: Hello Blame Block </pre> <p> <strong>The Disadvantage of using 2D Arrays:</strong> </p> <p>Suppose we want to store 4 Strings in an Array: {'Java', 'T', 'point', 'JavaTpoint'}. We will store the Strings like this:</p> <img src="//techcodeview.com/img/c-tutorial/46/an-array-strings-c-2.webp" alt="An Array of Strings in C"> <ul> <li>The number of rows will be equal to the number of Strings, but the number of columns will equal the length of the longest String.</li> <li>The memory allocated to all the Strings will be the size of the longest String, causing ' <strong>Memory wastage</strong> '.</li> <li>The orange part in the above representation is the memory wasted.</li> </ul> <h3>Using Pointers:</h3> <p>By using Pointers, we can avoid the Disadvantage of Memory wastage. But how do we do this?</p> <p>We need to create an Array of Pointers pointing to Strings. Hence, we need to create an Array of type ' <strong>char*</strong> '. This way, all the Strings are stored elsewhere in the exactly needed memory, and the Pointers in the Array point to those memory locations causing no memory wastage. More specifically, the Pointers in the Array point to the first Character of the Strings.</p> <p> <strong>Syntax to create an Array of Pointers:</strong> </p> <p>Data Type* name[] = {'Value 1', 'Value 2'…};</p> <p> <strong>Syntax to create an Array of String Pointers:</strong> </p> <p>char* Array[] = {'String 1', 'String 2'…};</p> <p> <strong>Representation:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/46/an-array-strings-c-3.webp" alt="An Array of Strings in C"> <p> <strong>Now, let us create an example String Array:</strong> </p> <pre> #include #include int main() { int i; char* Array[] = {'HI', 'UP', 'AT'}; printf('String Array:
'); for(i = 0; i <3; i++) { printf(\'%s
\', array[i]); } return 0; < pre> <p> <strong>Output:</strong> </p> <pre> String Array: HI UP AT </pre> <h3>Summary:</h3> <p>We cannot create a String Array like a normal one, as a String is an Array of Characters. We have two ways to do this:</p> <p> <strong>1. Using a Two-Dimensional Array:</strong> </p> <p>The Disadvantage of using this way is ' <strong>Memory wastage</strong> ,' as the memory allocated to every String in the Array will be the memory required to store the longest String of the Array.</p> <p> <strong>2. Using Pointers:</strong> </p> <p>Using Pointers, we create a single-dimensional Array of Pointers pointing to Strings. Following this method can eliminate the 'Memory wastage' Disadvantage.</p> <hr></3;></pre></3;> L'inconvénient de l'utilisation de tableaux 2D :
Supposons que nous souhaitions stocker 4 chaînes dans un tableau : {'Java', 'T', 'point', 'JavaTpoint'}. Nous stockerons les chaînes comme ceci :
- Le nombre de lignes sera égal au nombre de chaînes, mais le nombre de colonnes sera égal à la longueur de la chaîne la plus longue.
- La mémoire allouée à toutes les chaînes aura la taille de la chaîne la plus longue, provoquant ' Gaspillage de mémoire '.
- La partie orange dans la représentation ci-dessus représente la mémoire gaspillée.
Utiliser des pointeurs :
En utilisant des pointeurs, nous pouvons éviter l’inconvénient du gaspillage de mémoire. Mais comment fait-on cela ?
Nous devons créer un tableau de pointeurs pointant vers des chaînes. Par conséquent, nous devons créer un tableau de type ' carboniser* '. De cette façon, toutes les chaînes sont stockées ailleurs dans la mémoire exactement nécessaire, et les pointeurs du tableau pointent vers ces emplacements de mémoire, ce qui ne provoque aucun gaspillage de mémoire. Plus précisément, les pointeurs du tableau pointent vers le premier caractère des chaînes.
Syntaxe pour créer un tableau de pointeurs :
Type de données* nom[] = {'Valeur 1', 'Valeur 2'…} ;
Syntaxe pour créer un tableau de pointeurs de chaîne :
char* Array[] = {'Chaîne 1', 'Chaîne 2'…};
Représentation:
Maintenant, créons un exemple de tableau de chaînes :
mvc avec java
#include #include int main() { int i; char* Array[] = {'HI', 'UP', 'AT'}; printf('String Array:
'); for(i = 0; i <3; i++) { printf(\'%s
\', array[i]); } return 0; < pre> <p> <strong>Output:</strong> </p> <pre> String Array: HI UP AT </pre> <h3>Summary:</h3> <p>We cannot create a String Array like a normal one, as a String is an Array of Characters. We have two ways to do this:</p> <p> <strong>1. Using a Two-Dimensional Array:</strong> </p> <p>The Disadvantage of using this way is ' <strong>Memory wastage</strong> ,' as the memory allocated to every String in the Array will be the memory required to store the longest String of the Array.</p> <p> <strong>2. Using Pointers:</strong> </p> <p>Using Pointers, we create a single-dimensional Array of Pointers pointing to Strings. Following this method can eliminate the 'Memory wastage' Disadvantage.</p> <hr></3;> Résumé:
Nous ne pouvons pas créer un tableau de chaînes comme un tableau normal, car une chaîne est un tableau de caractères. Nous avons deux manières de procéder :
1. Utilisation d'un tableau bidimensionnel :
L'inconvénient d'utiliser cette méthode est ' Gaspillage de mémoire ', car la mémoire allouée à chaque chaîne du tableau sera la mémoire nécessaire pour stocker la chaîne la plus longue du tableau.
2. Utilisation de pointeurs :
À l’aide de pointeurs, nous créons un tableau unidimensionnel de pointeurs pointant vers des chaînes. Suivre cette méthode peut éliminer l’inconvénient du « gaspillage de mémoire ».