Let's look at the syntax for declar

Let's look at the syntax for declaring an array.
int examplearray[100]; /* This declares an array */
This would make an integer array with 100 slots (the places in which values of an array are stored). To access a specific part element of the array, you merely put the array name and, in brackets, an index number. This corresponds to a specific element of the array. The one trick is that the first index number, and thus the first element, is zero, and the last is the number of elements minus one. The indices for a 100 element array range from 0 to 99. Be careful not to "walk off the end" of the array by trying to access element 100!

What can you do with this simple knowledge? Let's say you want to store a string, because C has no built-in datatype for strings, you can make an array of characters.

For example:
char astring[100];
will allow you to declare a char array of 100 elements, or slots. Then you can receive input into it from the user, and when the user types in a string, it will go in the array, the first character of the string will be at position 0, the second character at position 1, and so forth. It is relatively easy to work with strings in this way because it allows support for any size string you can imagine all stored in a single variable with each element in the string stored in an adjacent location--think about how hard it would be to store nearly arbitrary sized strings using simple variables that only store one value. Since we can write loops that increment integers, it's very easy to scan through a string:
char astring[10];
int i = 0;
/* Using scanf isn't really the best way to do this; we'll talk about that
in the next tutorial, on strings */
scanf( "%s", astring );
for ( i = 0; i < 10; ++i )
{
if ( astring[i] == 'a' )
{
printf( "You entered an a!
" );
}
}

ผลลัพธ์ (ไทย) 1:

ลองดูที่ไวยากรณ์สำหรับการประกาศอาร์เรย์int examplearray [100]; / * นี้ประกาศเป็นแถว * /นี้จะทำให้อาร์เรย์จำนวนเต็มกับ 100 ช่อง (ตำแหน่งที่เก็บค่าของอาร์เรย์) การเข้าถึงเฉพาะส่วนองค์ประกอบของแถวลำดับ คุณเพียงใส่อาร์เรย์ชื่อ และ ในวง เล็บ หมายเลขดัชนี นี้สอดคล้องกับองค์ประกอบเฉพาะของอาร์เรย์ เทคนิคหนึ่งที่แรกดัชนีหมายเลข และองค์ประกอบแรก เป็นศูนย์ และสุดท้ายคือ จำนวนขององค์ประกอบลบหนึ่ง ดัชนีสำหรับองค์ประกอบ 100 แถวช่วงจาก 0 ถึง 99 ระวังไม่ให้ "เดินปิดท้าย" ของอาร์เรย์โดยการพยายามเข้าถึงองค์ประกอบ 100 คุณสามารถทำอะไร ด้วยความรู้เรื่องนี้ ลองสายอักขระที่คุณต้องการเก็บสาย เนื่องจาก C มีชนิดข้อมูลไม่มีการพูด คุณสามารถทำให้อาร์เรย์ของอักขระ ตัวอย่าง:อักขระ [100]; astring จะช่วยให้คุณสามารถประกาศอักขระแถวลำดับขององค์ประกอบ 100 สล็อต แล้ว คุณได้เข้ามาจากผู้ใช้ และเมื่อชนิดผู้ใช้ในสายอักขระ จะเป็นไปในอาร์เรย์ อักขระแรกของสายอักขระจะอยู่ที่ตำแหน่ง 0 อักขระที่ตำแหน่ง 1, 2 และต่อ ๆ ค่อนข้างง่ายต่อการทำงานกับสายอักขระในวิธีนี้ เพราะจะช่วยให้การสนับสนุนสำหรับสายอักขระขนาดใด ๆ ที่คุณสามารถจินตนาการทั้งหมดถูกเก็บไว้ในตัวแปรเดียวกับแต่ละองค์ประกอบในสายอักขระที่เก็บในตำแหน่งที่อยู่ติดกัน - คิดเกี่ยวกับว่ามันจะเก็บสายขนาดเกือบกำหนดโดยใช้ตัวแปรที่เก็บค่าหนึ่งเท่า นั้น เนื่องจากเราสามารถเขียนลูปที่เพิ่มจำนวนเต็ม มันง่ายมาก ๆ สแกนผ่านสายอักขระ:อักขระ [10]; astringint ฉัน = 0/ * ใช้ scanf ไม่ได้จริง ๆ วิธีที่ดีสุดนี้ เราจะพูดคุยเกี่ยวกับที่ ในบทถัดไป สายอักขระ * /scanf ("% s", astring);สำหรับ (ฉัน = 0 ฉัน < 10; ++ ฉัน){ ถ้า (astring [i] == 'a') { printf ("คุณใส่ผิด!
"); }}

ผลลัพธ์ (ไทย) 2:

ลองดูที่ไวยากรณ์สำหรับการประกาศอาร์เรย์.
int examplearray [100] / * นี้ประกาศอาร์เรย์ * /
นี้จะทำให้อาร์เรย์จำนวนเต็ม 100 ช่อง (สถานที่ค่าของอาร์เรย์จะถูกเก็บไว้) ในการเข้าถึงองค์ประกอบส่วนเฉพาะของอาเรย์, คุณเพียงใส่ชื่ออาร์เรย์และในวงเล็บตัวเลขดัชนี นี้สอดคล้องกับองค์ประกอบเฉพาะของอาร์เรย์ หนึ่งเคล็ดลับคือการที่ตัวเลขดัชนีแรกและทำให้องค์ประกอบแรกเป็นศูนย์และสุดท้ายคือจำนวนขององค์ประกอบลบหนึ่ง ดัชนีสำหรับช่วงอาร์เรย์องค์ประกอบ 100 จาก 0 ถึง 99 ระวังอย่าให้ "เดินออกจากปลาย" ของอาร์เรย์โดยพยายามที่จะเข้าถึงองค์ประกอบ 100! คุณสามารถทำอะไรที่มีความรู้แบบนี้? สมมติว่าคุณต้องการที่จะเก็บสตริงเพราะ C ไม่มีประเภทข้อมูลในตัวสำหรับสตริงคุณสามารถทำให้อาร์เรย์ของตัวอักษร. ตัวอย่างเช่นถ่าน astring [100]; จะทำให้คุณสามารถประกาศอาร์เรย์ถ่าน 100 องค์ประกอบหรือ ช่อง จากนั้นคุณจะได้รับการป้อนข้อมูลลงไปจากผู้ใช้และเมื่อผู้ใช้ในสายก็จะไปในอาร์เรย์ตัวอักษรตัวแรกของสตริงจะอยู่ที่ตำแหน่ง 0, ตัวละครที่สองที่ 1 ตำแหน่งและอื่น ๆ มันเป็นเรื่องง่ายที่จะทำงานกับสายในลักษณะนี้เพราะจะช่วยให้การสนับสนุนสำหรับสตริงขนาดที่คุณสามารถจินตนาการทั้งหมดที่เก็บไว้ในตัวแปรเดียวที่มีองค์ประกอบในสตริงแต่ละที่เก็บไว้ในสถานที่ที่อยู่ใกล้เคียง - คิดเกี่ยวกับวิธีการที่ยากก็จะเป็นในการจัดเก็บ สายกลางโดยพลเกือบใช้ตัวแปรง่ายๆที่เก็บเพียงหนึ่งค่า เนื่องจากเราสามารถเขียนลูปที่เพิ่มจำนวนเต็มมันเป็นเรื่องง่ายมากที่จะสแกนผ่านสตริง: astring ถ่าน [10]; int i = 0; / * การใช้ scanf ไม่ได้จริงๆวิธีที่ดีที่สุดที่จะทำนี้ เราจะพูดคุยเกี่ยวกับว่าในการกวดวิชาต่อไปในสาย * / scanf ("% s", astring) สำหรับ (i = 0; i <10; ++ i) { if (astring [ผม] == ' ') { printf ("คุณเข้ามา n"); } }

ผลลัพธ์ (ไทย) 3:

มาดูไวยากรณ์สำหรับการประกาศ array .
1 examplearray [ 100 ] ; / * นี้ประกาศอาร์เรย์ * /
นี่จะทำให้จำนวนเต็มเรย์กับ 100 ช่อง ( สถานที่ที่ค่าของอาร์เรย์จะถูกเก็บไว้ ) ในการเข้าถึงองค์ประกอบส่วนหนึ่งที่เฉพาะเจาะจงของอาร์เรย์ คุณเพียงแค่ใส่ชื่อเรย์ และ ใน วงเล็บ เป็นเลขดัชนี นี้สอดคล้องกับองค์ประกอบเฉพาะของเรย์หนึ่งเคล็ดลับคือการที่ตัวเลขดัชนีครั้งแรก และดังนั้นจึง องค์ประกอบแรกคือศูนย์ และสุดท้ายคือองค์ประกอบลบด้วยหนึ่ง ดัชนีสำหรับ 100 องค์ประกอบอาร์เรย์ช่วงจาก 0 ถึง 99 ระวังอย่าให้ " เดินปิดท้าย " ของอาร์เรย์โดยพยายามเข้าถึงธาตุ 100

สิ่งที่คุณสามารถทำอะไรกับความรู้ที่เรียบง่ายนี้ สมมติว่า คุณต้องการเก็บสายเพราะ C ไม่มีในตัวชนิดข้อมูลสำหรับสตริง คุณสามารถสร้างอาร์เรย์ของอักขระ ตัวอย่าง :


astring char [ 100 ] ;
จะอนุญาตให้คุณประกาศ char array 100 ธาตุ หรือ สล็อต แล้วคุณจะได้รับการป้อนข้อมูลเข้าไปในมัน จากผู้ใช้เมื่อผู้ใช้พิมพ์ข้อความ มันจะไปอยู่ในอาร์เรย์ ตัวอักษรตัวแรกของสตริงจะอยู่ที่ตำแหน่ง 0 , ตัวที่สองที่ตำแหน่งที่ 1และอื่น ๆ มันค่อนข้างง่ายที่จะทำงานกับสตริงในวิธีนี้เพราะมันช่วยให้การสนับสนุนสำหรับสายขนาดใด ๆ คุณสามารถนึกภาพทั้งหมดเก็บไว้ในตัวแปรเดียว กับแต่ละองค์ประกอบในสตริงที่เก็บไว้ในสถานที่ที่อยู่ติดกัน -- คิดเกี่ยวกับวิธียากมันจะเก็บเกือบหนึ่งขนาดสายใช้ง่ายเพียงหนึ่งตัวแปรเก็บค่าเนื่องจากเราสามารถเขียนลูปที่เพิ่มจํานวนเต็ม มันง่ายมากที่จะสแกนผ่านสายชาร์ astring
[ 10 ] ;
1 = 0 ;
/ * ใช้ scanf ไม่ได้จริงๆวิธีที่ดีที่สุดที่จะทำนี้ เราค่อยคุยกัน
ในการกวดวิชาถัดไป บนสาย * /
scanf ( " % s " astring ) ;
( i = 0 ; ฉัน < 10 ; I )
{
ถ้า ( astring [ i ] = = ' ' ) {

printf ( " คุณป้อน ! "

} } ) ;