การส่งอาร์เรย์เป็นอาร์กิวเมนต์ไปยังฟังก์ชันใน C

Question 1

ฉันเขียนฟังก์ชันที่มีอาร์เรย์เป็นอาร์กิวเมนต์และเรียกใช้โดยการส่งผ่านค่าอาร์เรย์ดังนี้

void arraytest(int a[])
{
    // changed the array a
    a[0]=a[0]+a[1];
    a[1]=a[0]-a[1];
    a[0]=a[0]-a[1];
}

void main()
{
    int arr[]={1,2};
    printf("%d \t %d",arr[0],arr[1]);
    arraytest(arr);
    printf("\n After calling fun arr contains: %d\t %d",arr[0],arr[1]);
}

สิ่งที่ฉันพบคือแม้ว่าฉันจะเรียกarraytest()ใช้ฟังก์ชันโดยการส่งผ่านค่า แต่สำเนาต้นฉบับint arr[]ก็เปลี่ยนไป

คุณช่วยอธิบายได้ไหมว่าทำไม?

Question 2

เมื่อส่งอาร์เรย์เป็นพารามิเตอร์สิ่งนี้

void arraytest(int a[])

หมายความว่าเหมือนกับ

void arraytest(int *a)

ดังนั้นคุณกำลังแก้ไขค่าใน main

ด้วยเหตุผลทางประวัติศาสตร์อาร์เรย์ไม่ใช่พลเมืองชั้นหนึ่งและไม่สามารถส่งผ่านค่าได้

Question 3

หากคุณต้องการส่งอาร์เรย์มิติเดียวเป็นอาร์กิวเมนต์ในฟังก์ชันคุณจะต้องประกาศพารามิเตอร์ที่เป็นทางการด้วยวิธีใดวิธีหนึ่งจากสามวิธีต่อไปนี้และวิธีการประกาศทั้งสามจะให้ผลลัพธ์ที่คล้ายกันเนื่องจากแต่ละวิธีจะบอกคอมไพเลอร์ว่าตัวชี้จำนวนเต็มกำลังไป ที่จะได้รับ

int func(int arr[], ...){
    .
    .
    .
}

int func(int arr[SIZE], ...){
    .
    .
    .
}

int func(int* arr, ...){
    .
    .
    .
}

ดังนั้นคุณกำลังแก้ไขค่าดั้งเดิม

ขอบคุณ !!!

Question 4

คุณไม่ได้ส่งผ่านอาร์เรย์เป็นสำเนา เป็นเพียงตัวชี้ที่ชี้ไปยังแอดเดรสที่องค์ประกอบแรกของอาร์เรย์อยู่ในหน่วยความจำ

Question 5

คุณกำลังส่งที่อยู่ขององค์ประกอบแรกของอาร์เรย์

Question 6

อาร์เรย์ใน C จะถูกแปลงในกรณีส่วนใหญ่เป็นตัวชี้ไปยังองค์ประกอบแรกของอาร์เรย์เอง และอาร์เรย์รายละเอียดเพิ่มเติมที่ส่งผ่านไปยังฟังก์ชันจะถูกแปลงเป็นตัวชี้เสมอ

นี่คือคำพูดจากK & R2nd :

เมื่อชื่ออาร์เรย์ถูกส่งผ่านไปยังฟังก์ชันสิ่งที่ส่งผ่านคือตำแหน่งขององค์ประกอบเริ่มต้น ภายในฟังก์ชันที่เรียกว่าอาร์กิวเมนต์นี้เป็นตัวแปรโลคัลดังนั้นพารามิเตอร์ชื่ออาร์เรย์จึงเป็นตัวชี้นั่นคือตัวแปรที่มีแอดเดรส

การเขียน:

void arraytest(int a[])

มีความหมายเหมือนกับการเขียน:

void arraytest(int *a)

ดังนั้นแม้ว่าคุณจะไม่ได้เขียนมันอย่างชัดเจน แต่มันก็เหมือนกับที่คุณกำลังส่งตัวชี้และคุณกำลังแก้ไขค่าในหลัก

สำหรับข้อมูลเพิ่มเติมฉันขอแนะนำให้อ่านสิ่งนี้จริงๆ

นอกจากนี้คุณสามารถค้นหาคำตอบอื่น ๆ เกี่ยวกับ SO ได้ที่นี่

Question 7

คุณกำลังส่งค่าของตำแหน่งหน่วยความจำของสมาชิกตัวแรกของอาร์เรย์

ดังนั้นเมื่อคุณเริ่มแก้ไขอาร์เรย์ภายในฟังก์ชันคุณกำลังแก้ไขอาร์เรย์เดิม

โปรดจำไว้ว่าเป็นa[1]*(a+1)

Question 8

ใน C ยกเว้นกรณีพิเศษบางประการการอ้างอิงอาร์เรย์จะ "สลายตัว" ไปยังตัวชี้ไปยังองค์ประกอบแรกของอาร์เรย์เสมอ ดังนั้นจึงไม่สามารถส่งอาร์เรย์ "ตามค่า" ได้ อาร์เรย์ในการเรียกใช้ฟังก์ชันจะถูกส่งผ่านไปยังฟังก์ชันเป็นตัวชี้ซึ่งคล้ายกับการส่งผ่านอาร์เรย์โดยการอ้างอิง

แก้ไข: มีกรณีพิเศษสามกรณีที่อาร์เรย์ไม่สลายตัวเป็นตัวชี้ไปที่องค์ประกอบแรก:

sizeof aไม่เหมือนกับsizeof (&a[0]).
&aไม่เหมือนกับ&(&a[0])(และไม่เหมือนกับ&a[0])
char b[] = "foo"ไม่เหมือนกับchar b[] = &("foo").

Question 9

การส่งอาร์เรย์หลายมิติเป็นอาร์กิวเมนต์ไปยังฟังก์ชัน การส่งผ่านอาร์เรย์ dim หนึ่งอาร์เรย์เนื่องจากอาร์กิวเมนต์นั้นไม่สำคัญมากหรือน้อย ลองมาดูกรณีที่น่าสนใจยิ่งขึ้นในการส่งผ่านอาร์เรย์ 2 สลัว ใน C คุณไม่สามารถใช้ตัวชี้เพื่อสร้างตัวชี้ ( int **) แทนอาร์เรย์ 2 สลัวได้ ลองดูตัวอย่าง:

void assignZeros(int(*arr)[5], const int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 5; j++) {
            *(*(arr + i) + j) = 0;
            // or equivalent assignment
            arr[i][j] = 0;
        }
    }

ที่นี่ฉันได้ระบุฟังก์ชันที่ใช้เป็นอาร์กิวเมนต์แรกตัวชี้ไปยังอาร์เรย์ของจำนวนเต็ม 5 ตัว ฉันสามารถส่งเป็นอาร์กิวเมนต์อาร์เรย์ 2 สลัวที่มี 5 คอลัมน์:

int arr1[1][5]
int arr1[2][5]
...
int arr1[20][5]
...

คุณอาจคิดที่จะกำหนดฟังก์ชันทั่วไปที่สามารถรับอาร์เรย์ 2 dim และเปลี่ยนลายเซ็นฟังก์ชันได้ดังนี้:

void assignZeros(int ** arr, const int rows, const int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            *(*(arr + i) + j) = 0;
        }
    }
}

รหัสนี้จะคอมไพล์ แต่คุณจะได้รับข้อผิดพลาดรันไทม์เมื่อพยายามกำหนดค่าในลักษณะเดียวกับในฟังก์ชันแรก ดังนั้นใน C อาร์เรย์หลายมิติจึงไม่เหมือนกับพอยน์เตอร์ถึงพอยน์เตอร์ ... ถึงพอยน์เตอร์ An int(*arr)[5]เป็นตัวชี้ไปยังอาร์เรย์ของ 5 องค์ประกอบและint(*arr)[6] เป็นตัวชี้ไปยังอาร์เรย์ของ 6 องค์ประกอบและเป็นตัวชี้ไปยังประเภทต่างๆ!

วิธีการกำหนดอาร์กิวเมนต์ของฟังก์ชันสำหรับมิติข้อมูลที่สูงขึ้น? ง่ายๆแค่ทำตามแบบ! นี่คือฟังก์ชั่นเดียวกันที่ปรับให้รับอาร์เรย์ 3 มิติ:

void assignZeros2(int(*arr)[4][5], const int dim1, const int dim2, const int dim3) {
    for (int i = 0; i < dim1; i++) {
        for (int j = 0; j < dim2; j++) {
            for (int k = 0; k < dim3; k++) {
                *(*(*(arr + i) + j) + k) = 0;
                // or equivalent assignment
                arr[i][j][k] = 0;
            }
        }
    }
}

สิ่งที่คุณคาดหวังมันสามารถใช้เป็นอาร์กิวเมนต์อาร์เรย์ 3 สลัวใดก็ได้ที่มีในมิติที่สอง 4 องค์ประกอบและในมิติที่สาม 5 องค์ประกอบ อะไรแบบนี้ก็โอเค:

arr[1][4][5]
arr[2][4][5]
...
arr[10][4][5]
...

แต่เราต้องระบุขนาดมิติข้อมูลทั้งหมดจนถึงขนาดแรก

Question 10

การใช้อาร์เรย์มาตรฐานใน C พร้อมการสลายตัวแบบธรรมชาติจากอาร์เรย์เป็น ptr

@ Bo Persson ระบุอย่างถูกต้องในคำตอบที่ยอดเยี่ยมของเขาที่นี่ :

เมื่อส่งอาร์เรย์เป็นพารามิเตอร์สิ่งนี้
void arraytest(int a[])
หมายความว่าเหมือนกับ
void arraytest(int *a)

อย่างไรก็ตามขอฉันเพิ่มด้วยว่าทั้งสองรูปแบบข้างต้นยัง:

หมายความว่าเหมือนกับ
```
 void arraytest(int a[0])
```
ซึ่งหมายความว่าเหมือนกับ
```
 void arraytest(int a[1])
```
ซึ่งหมายความว่าเหมือนกับ
```
 void arraytest(int a[2])
```
ซึ่งหมายความว่าเหมือนกับ
```
 void arraytest(int a[1000])
```
เป็นต้น

ในทุกตัวอย่างอาร์เรย์ข้างต้นประเภทพารามิเตอร์อินพุตจะสลายตัวเป็น anint *และสามารถเรียกได้โดยไม่มีคำเตือนและไม่มีข้อผิดพลาดแม้จะ-Wall -Wextra -Werrorเปิดตัวเลือกการสร้างไว้แล้วก็ตาม(ดูที่repo ของฉันที่นี่สำหรับรายละเอียดเกี่ยวกับตัวเลือกการสร้างทั้ง 3 นี้) เช่น นี้:

int array1[2];
int * array2 = array1;

// works fine because `array1` automatically decays from an array type
// to `int *`
arraytest(array1);
// works fine because `array2` is already an `int *` 
arraytest(array2);

เป็นเรื่องของความเป็นจริง "ขนาด" ค่า (ก[0], [1], [2], [1000]ฯลฯ ) ภายในพารามิเตอร์อาร์เรย์ที่นี่เป็นที่เห็นได้ชัดเพียงเพื่อความงาม / วัตถุประสงค์เอกสารด้วยตนเองและสามารถเป็นจำนวนเต็มบวกใด ๆ (size_tพิมพ์ฉันคิด) ที่คุณต้องการ!

อย่างไรก็ตามในทางปฏิบัติคุณควรใช้เพื่อระบุขนาดขั้นต่ำของอาร์เรย์ที่คุณคาดหวังว่าฟังก์ชันจะได้รับดังนั้นเมื่อเขียนโค้ดคุณจะติดตามและตรวจสอบได้ง่าย มาตรฐานMISRA-C-2012 ( ซื้อ / ดาวน์โหลด PDF เวอร์ชัน 236-pg 2012 ของมาตรฐานราคา 15.00 ปอนด์ที่นี่ ) ไปไกลถึงสถานะ (เน้นเพิ่ม):

กฎข้อ 17.5 อาร์กิวเมนต์ของฟังก์ชันที่สอดคล้องกับพารามิเตอร์ที่ประกาศว่ามีประเภทอาร์เรย์ต้องมีจำนวนองค์ประกอบที่เหมาะสม

...

หากพารามิเตอร์ถูกประกาศเป็นอาร์เรย์ที่มีขนาดที่ระบุอาร์กิวเมนต์ที่เกี่ยวข้องในการเรียกใช้ฟังก์ชันแต่ละครั้งควรชี้ไปที่วัตถุที่มีองค์ประกอบอย่างน้อยเท่าอาร์เรย์

...

การใช้ตัวประกาศอาร์เรย์สำหรับพารามิเตอร์ฟังก์ชันระบุอินเทอร์เฟซของฟังก์ชันได้ชัดเจนกว่าการใช้ตัวชี้ จำนวนองค์ประกอบต่ำสุดที่ฟังก์ชันคาดหวังไว้นั้นมีการระบุไว้อย่างชัดเจนในขณะที่ตัวชี้ไม่สามารถทำได้

กล่าวอีกนัยหนึ่งก็คือพวกเขาแนะนำให้ใช้รูปแบบขนาดที่ชัดเจนแม้ว่าในทางเทคนิคมาตรฐาน C จะไม่ได้บังคับใช้ก็ตามแต่อย่างน้อยก็ช่วยชี้แจงให้คุณทราบในฐานะนักพัฒนาและสำหรับคนอื่น ๆ ที่ใช้โค้ดว่าอาร์เรย์ขนาดใดที่ฟังก์ชันคาดหวัง คุณจะผ่านเข้าไป

บังคับประเภทความปลอดภัยในอาร์เรย์ใน C

ดังที่ @Winger Sendon ชี้ให้เห็นในความคิดเห็นด้านล่างคำตอบของฉันเราสามารถบังคับให้ C รักษาประเภทอาร์เรย์ให้แตกต่างกันตามขนาดอาร์เรย์ !

ขั้นแรกคุณต้องตระหนักว่าในตัวอย่างของฉันข้างต้นโดยใช้สิ่งint array1[2];นี้: arraytest(array1);ทำให้array1สลายตัวเป็นint *ไฟล์. อย่างไรก็ตามหากคุณใช้ที่อยู่ array1แทนและโทรarraytest(&array1)ไปคุณจะมีพฤติกรรมที่แตกต่างไปจากเดิมอย่างสิ้นเชิง! ตอนนี้ยังไม่สลายตัวเป็นint *! ประเภทของ&array1คือint (*)[2]ซึ่งหมายถึง"ตัวชี้ไปยังอาร์เรย์ขนาด 2 ของ int"หรือ"ตัวชี้ไปยังอาร์เรย์ขนาด 2 ของประเภท int"แทน ดังนั้นคุณสามารถ FORCE C เพื่อตรวจสอบความปลอดภัยของประเภทในอาร์เรย์เช่นนี้:

void arraytest(int (*a)[2])
{
    // my function here
}

รูปแบบนี้เป็นเรื่องยากที่จะอ่าน แต่คล้ายกับที่ของตัวชี้ฟังก์ชัน เครื่องมือออนไลน์cdeclบอกเราว่าint (*a)[2]: "ประกาศเป็นตัวชี้ไปยังอาร์เรย์ 2 ของ int" (ตัวชี้ไปที่อาร์เรย์ 2 intวินาที) อย่าสับสนกับเวอร์ชันที่ไม่มีวงเล็บ: int * a[2]ซึ่งหมายความว่า: "ประกาศเป็นอาร์เรย์ 2 ของตัวชี้เป็น int" (อาร์เรย์ 2 พอยน์เตอร์ถึงint)

ตอนนี้ฟังก์ชันนี้ต้องการให้คุณเรียกใช้ด้วยตัวดำเนินการแอดเดรส ( &) เช่นนี้โดยใช้เป็นพารามิเตอร์อินพุตชี้ไปที่อาร์เรย์ของขนาดที่ถูกต้อง!:

int array1[2];

// ok, since the type of `array1` is `int (*)[2]` (ptr to array of 
// 2 ints)
arraytest(&array1); // you must use the & operator here to prevent
                    // `array1` from otherwise automatically decaying
                    // into `int *`, which is the WRONG input type here!

อย่างไรก็ตามสิ่งนี้จะทำให้เกิดคำเตือน:

int array1[2];

// WARNING! Wrong type since the type of `array1` decays to `int *`:
//      main.c:32:15: warning: passing argument 1 of ‘arraytest’ from 
//      incompatible pointer type [-Wincompatible-pointer-types]                                                            
//      main.c:22:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
arraytest(array1); // (missing & operator)

คุณอาจจะทดสอบรหัสที่นี่

ในการบังคับให้คอมไพเลอร์ C เปลี่ยนคำเตือนนี้เป็นข้อผิดพลาดดังนั้นคุณต้องเรียกarraytest(&array1);ใช้เฉพาะอาร์เรย์อินพุตที่มีขนาดและประเภทที่ถูกต้องเท่านั้นให้int array1[2];เพิ่ม-Werrorตัวเลือกการสร้างของคุณ หากเรียกใช้โค้ดทดสอบด้านบนบน onlinegdb.com ให้คลิกไอคอนรูปเฟืองที่ด้านบนขวาและคลิกที่ "Extra Compiler Flags" เพื่อพิมพ์ตัวเลือกนี้ในตอนนี้คำเตือนนี้:

main.c:34:15: warning: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Wincompatible-pointer-types]                                                            
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’

จะกลายเป็นข้อผิดพลาดของการสร้างนี้:

main.c: In function ‘main’:
main.c:34:15: error: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Werror=incompatible-pointer-types]
     arraytest(array1); // warning!
               ^~~~~~
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
 void arraytest(int (*a)[2])
      ^~~~~~~~~
cc1: all warnings being treated as errors

โปรดทราบว่าคุณยังสามารถสร้างตัวชี้ "type safe" ให้กับอาร์เรย์ขนาดที่กำหนดได้เช่นนี้

int array[2];
// "type safe" ptr to array of size 2 of int:
int (*array_p)[2] = &array;

... แต่ฉันไม่จำเป็นต้องแนะนำสิ่งนี้เพราะมันทำให้ฉันนึกถึงการแสดงตลก C ++ จำนวนมากที่ใช้ในการบังคับความปลอดภัยของประเภททุกที่ด้วยต้นทุนที่สูงเป็นพิเศษสำหรับความซับซ้อนของไวยากรณ์ภาษาความฟุ่มเฟือยและความยากลำบากในการออกแบบโค้ดซึ่งฉันไม่ชอบและ เคยพูดคุยกันหลายครั้งก่อนหน้านี้ (เช่นดู"My Thoughts on C ++" ที่นี่ )

สำหรับการทดสอบและการทดลองเพิ่มเติมโปรดดูที่ลิงค์ด้านล่าง

อ้างอิง

ดูลิงก์ด้านบน นอกจากนี้:

การทดลองโค้ดของฉันออนไลน์: https://onlinegdb.com/B1RsrBDFD

Question 11

อาร์เรย์จะถูกส่งผ่านโดยการอ้างอิงเสมอหากคุณใช้a[]หรือ*a:

int* printSquares(int a[], int size, int e[]) {   
    for(int i = 0; i < size; i++) {
        e[i] = i * i;
    }
    return e;
}

int* printSquares(int *a, int size, int e[]) {
    for(int i = 0; i < size; i++) {
        e[i] = i * i;
    }
    return e;
}