מערך הוא מבנה הנתונים הפשוט ביותר ב-C המאחסן נתונים הומוגניים במיקומי זיכרון רציפים. אם ברצוננו ליצור מערך, אנו מצהירים על סוג הנתונים ונותנים לתוכו אלמנטים:
#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;> ב-C, תו ומחרוזת הם סוגי נתונים נפרדים, בניגוד לשפות תכנות אחרות כמו Python. מחרוזת היא אוסף של תווים. לפיכך, כדי להגדיר מחרוזת, אנו משתמשים במערך תווים:
#include int main() { char str[8]; printf('Enter a String: '); scanf('%s', &str); printf('%s', str); } תְפוּקָה:
Enter a String: Hello Hello
כעת, אנו רוצים ליצור מערך של מחרוזות מה שאומר שאנו מנסים ליצור מערך של מערכי תווים. יש לנו שתי דרכים לעשות זאת:
- שימוש במערכים דו מימדיים
- שימוש במצביעים
שימוש במערכים דו מימדיים:
יצירת מערך מחרוזות הוא אחד מהיישומים של מערכים דו מימדיים. כדי לקבל תמונה של ההסדר, שים לב לייצוג שלהלן:
כי נניח שאנחנו רוצים ליצור מערך של 3 מחרוזות בגודל 5:
עדכון מ- join sql
כל מחרוזת במערך מחרוזת חייבת להסתיים עם תו null. זה הנכס של מחרוזת ב-C.
תחביר ליצירת מערך דו מימדי:
Data_type name[rows][columns] = {{values in row 1}, {values in row 2}…}; תחביר ליצירת מערך מחרוזות:
char Array[rows][columns] = {'String1', 'String2'...}; כעת, הבה ניצור מערך מחרוזות לדוגמה:
char tostring java
- שים לב שכאשר אנו מקצים את מספר השורות והעמודות, עלינו להתייחס ל-Null Character לאורך.
#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] = {'Black', 'Blame', 'Black'} -> {{'B', 'l', 'a', 'c', 'k', ' ' }, {'B', 'l', 'a', 'm', 'e', ' '}, {'B', 'l', 'a', 'c', 'k', ' '}}
- אנחנו לא יכולים לתפעל ישירות את המחרוזות במערך מכיוון שמחרוזת היא סוג נתונים בלתי ניתן לשינוי. המהדר מעלה שגיאה:
char Array[0] = 'Hello';
תְפוּקָה:
[Error] assignment to expression with Array type
- אנו יכולים להשתמש בפונקציה strcpy() כדי להעתיק את הערך על ידי ייבוא קובץ הכותרת של 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;> החיסרון בשימוש במערכים דו מימדיים:
נניח שאנו רוצים לאחסן 4 מחרוזות במערך: {'Java', 'T', 'point', 'JavaTpoint'}. נאחסן את המחרוזות כך:
- מספר השורות יהיה שווה למספר המחרוזות, אך מספר העמודות יהיה שווה לאורכה של המחרוזת הארוכה ביותר.
- הזיכרון שהוקצה לכל המחרוזות יהיה בגודל של המחרוזת הארוכה ביותר, מה שגורם ל' בזבוז זיכרון '.
- החלק הכתום בייצוג לעיל הוא הזיכרון המבוזבז.
שימוש במצביעים:
על ידי שימוש ב-Pointers, נוכל למנוע את החיסרון של בזבוז זיכרון. אבל איך אנחנו עושים את זה?
עלינו ליצור מערך מצביעים המצביע על מחרוזות. לפיכך, עלינו ליצור מערך מסוג ' לְהַשְׁחִיר* '. בדרך זו, כל המחרוזות מאוחסנות במקום אחר בזיכרון הדרוש בדיוק, והמצביעים במערך מצביעים על מיקומי זיכרון אלה שאינם גורמים לבזבוז זיכרון. ליתר דיוק, המצביעים במערך מצביעים על הדמות הראשונה של המיתרים.
תחביר ליצירת מערך מצביעים:
סוג נתונים* name[] = {'ערך 1', 'ערך 2'...};
תחביר ליצירת מערך של מצביעי מחרוזת:
char* Array[] = {'מחרוזת 1', 'מחרוזת 2'...};
יִצוּג:
כעת, הבה ניצור מערך מחרוזות לדוגמה:
בונה מחרוזות ג'אווה
#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;> סיכום:
איננו יכולים ליצור מערך מחרוזת כמו מערך רגיל, מכיוון שמחרוזת היא מערך של תווים. יש לנו שתי דרכים לעשות זאת:
1. שימוש במערך דו מימדי:
החיסרון בשימוש בדרך זו הוא ' בזבוז זיכרון ,' שכן הזיכרון שהוקצה לכל מחרוזת במערך יהיה הזיכרון הנדרש לאחסון המחרוזת הארוכה ביותר של המערך.
2. שימוש במצביעים:
באמצעות מצביעים, אנו יוצרים מערך חד-ממדי של מצביעים המצביע על מחרוזות. ביצוע שיטה זו יכול לבטל את החיסרון 'בזבוז זיכרון'.