ผ่านโดยอ้างอิงในค

ถ้า C ไม่สนับสนุนการส่งตัวแปรโดยการอ้างอิงทำไมถึงใช้งานได้?

#include <stdio.h>

void f(int *j) {
  (*j)++;
}

int main() {
  int i = 20;
  int *p = &i;
  f(p);
  printf("i = %d\n", i);

  return 0;
}

เอาท์พุท:

$ gcc -std=c99 test.c
$ a.exe
i = 21 

เนื่องจากคุณกำลังส่งค่าของตัวชี้ไปยังเมธอดจากนั้นทำการยกเลิกการอ้างอิงเพื่อรับจำนวนเต็มที่ชี้

ที่ไม่ผ่านการอ้างอิงนั่นคือ pass-by-value ตามที่คนอื่น ๆ ระบุไว้

ภาษา C คือการส่งต่อค่าโดยไม่มีข้อยกเว้น การส่งตัวชี้เป็นพารามิเตอร์ไม่ได้หมายถึงการส่งต่อแบบอ้างอิง

กฎมีดังต่อไปนี้:

ฟังก์ชั่นไม่สามารถเปลี่ยนค่าพารามิเตอร์จริง

ลองดูความแตกต่างระหว่างพารามิเตอร์สเกลาร์และตัวชี้ของฟังก์ชัน

ตัวแปรสเกลาร์

โปรแกรมสั้น ๆ นี้แสดงการส่งต่อค่าโดยใช้ตัวแปรสเกลาร์ paramเรียกว่าพารามิเตอร์อย่างเป็นทางการและvariableที่ฟังก์ชั่นการภาวนาเรียกว่าพารามิเตอร์จริง หมายเหตุการเพิ่มฟังก์ชั่นไม่เปลี่ยนแปลงparamvariable

#include <stdio.h>

void function(int param) {
    printf("I've received value %d\n", param);
    param++;
}

int main(void) {
    int variable = 111;

    function(variable);
    printf("variable %d\m", variable);
    return 0;
}

ผลที่ได้คือ

I've received value 111
variable=111

ภาพลวงตาของการอ้างอิงผ่าน

เราเปลี่ยนชิ้นส่วนของรหัสเล็กน้อย paramเป็นตัวชี้ในขณะนี้

#include <stdio.h>

void function2(int *param) {
    printf("I've received value %d\n", *param);
    (*param)++;
}

int main(void) {
    int variable = 111;

    function2(&variable);
    printf("variable %d\n", variable);
    return 0;
}

ผลที่ได้คือ

I've received value 111
variable=112

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

พอยน์เตอร์ - ผ่านโดยค่า

เราจะแสดง / พิสูจน์ความจริงนั้นได้อย่างไร? บางทีเราสามารถลองตัวอย่างแรกของตัวแปรสเกลาร์ได้ แต่แทนที่จะใช้สเกลาร์เราใช้ที่อยู่ (ตัวชี้) เรามาดูกันว่าจะช่วยได้ไหม

#include <stdio.h>

void function2(int *param) {
    printf("param's address %d\n", param);
    param = NULL;
}

int main(void) {
    int variable = 111;
    int *ptr = &variable;

    function2(ptr);
    printf("ptr's address %d\n", ptr);
    return 0;
}

ผลลัพธ์จะเป็นที่อยู่สองที่เท่ากัน (ไม่ต้องกังวลเกี่ยวกับค่าที่แน่นอน)

ตัวอย่างผลลัพธ์:

param's address -1846583468
ptr's address -1846583468

ในความเห็นของฉันสิ่งนี้พิสูจน์ได้อย่างชัดเจนว่าพอยน์เตอร์นั้นผ่านตามตัวอักษร มิฉะนั้นptrจะเกิดขึ้นNULLหลังจากการเรียกใช้ฟังก์ชัน

ใน C Pass-by-Reference จะถูกจำลองโดยส่งผ่านที่อยู่ของตัวแปร (ตัวชี้) และยกเลิกการกำหนดที่อยู่ภายในฟังก์ชันเพื่ออ่านหรือเขียนตัวแปรจริง สิ่งนี้จะถูกเรียกว่า "C style pass-by-reference"

ที่มา: www-cs-students.stanford.edu

เนื่องจากไม่มีรหัสผ่านอ้างอิงในรหัสด้านบน การใช้พอยน์เตอร์ (เช่นvoid func(int* p)) คือการผ่านที่อยู่ นี่คือรหัสผ่านใน C ++ (จะไม่ทำงานใน C):

void func(int& ref) {ref = 4;}

...
int a;
func(a);
// a is 4 now

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

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

ชนิดข้อมูลอ้างอิง C ++ นั้นมีประสิทธิภาพน้อยกว่า แต่ถือว่าปลอดภัยกว่าประเภทตัวชี้ที่สืบทอดมาจาก C นี่คือตัวอย่างของคุณซึ่งปรับให้ใช้การอ้างอิง C ++ :

void f(int &j) {
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

คุณผ่านตัวชี้ (ตำแหน่งที่อยู่) โดยค่า

มันเหมือนกับการพูดว่า "นี่คือสถานที่ที่มีข้อมูลที่ฉันต้องการให้คุณอัปเดต"

p เป็นตัวแปรตัวชี้ ค่าของมันคือที่อยู่ของ i เมื่อคุณโทรหา f คุณจะผ่านค่าของ p ซึ่งเป็นที่อยู่ของ i

ไม่มีการส่งต่อโดยอ้างอิงใน C แต่ p "อ้างอิง" ถึง i และคุณผ่านค่า p

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

void add_number(int *a) {
    *a = *a + 2;
}

int main(int argc, char *argv[]) {
   int a = 2;

   printf("before pass by reference, a == %i\n", a);
   add_number(&a);
   printf("after  pass by reference, a == %i\n", a);

   printf("before pass by reference, a == %p\n", &a);
   add_number(&a);
   printf("after  pass by reference, a == %p\n", &a);

}

before pass by reference, a == 2
after  pass by reference, a == 4
before pass by reference, a == 0x7fff5cf417ec
after  pass by reference, a == 0x7fff5cf417ec

เพราะคุณกำลังส่งพอยน์เตอร์ (ที่อยู่หน่วยความจำ) ไปยังตัวแปร p เข้าสู่ฟังก์ชัน f คุณกำลังผ่านตัวชี้ไม่ใช่การอ้างอิง

คำตอบสั้น ๆ : ใช่ C ใช้การส่งพารามิเตอร์โดยการอ้างอิงโดยใช้พอยน์เตอร์

ในขณะที่การนำพารามิเตอร์ไปใช้ผู้ออกแบบภาษาการเขียนโปรแกรมใช้กลยุทธ์ที่แตกต่างกันสามแบบ (หรือแบบจำลองความหมาย): ถ่ายโอนข้อมูลไปยังโปรแกรมย่อยรับข้อมูลจากโปรแกรมย่อยหรือทำทั้งสองอย่าง โมเดลเหล่านี้เป็นที่รู้จักกันทั่วไปว่าเป็นในโหมด, โหมดออก, และโหมด inout ตามลำดับ

หลายรุ่นได้รับการออกแบบโดยนักออกแบบภาษาเพื่อใช้กลยุทธ์การส่งผ่านพารามิเตอร์เบื้องต้นทั้งสามนี้:

Pass-by-Value (ในความหมายของโหมด) Pass-by-Value (ความหมายของโหมดออก) Pass-by-Value (ผลลัพธ์ความหมายโหมด inout) Pass-by-Value (ความหมายโหมด inout) Pass-by-Reference ความหมาย)

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

การใช้พารามิเตอร์ที่ผ่านใน C: C ใช้การส่งต่อตามค่าและซีแมนทิกส์แบบบายพาสโดยอ้างอิง (โหมด inout) โดยใช้พอยน์เตอร์เป็นพารามิเตอร์ ตัวชี้ถูกส่งไปยังโปรแกรมย่อยและไม่มีการคัดลอกข้อมูลจริงเลย อย่างไรก็ตามเนื่องจากตัวชี้เป็นเส้นทางการเข้าถึงข้อมูลของรูทีนหลักโปรแกรมย่อยอาจเปลี่ยนข้อมูลในรูทีนหลัก C ใช้วิธีนี้จาก ALGOL68

พารามิเตอร์การใช้งานผ่านใน C ++: C ++ ยังใช้ซีแมนทิกส์แบบอ้างอิงถึงกัน (โหมด inout) โดยใช้พอยน์เตอร์และใช้พอยน์เตอร์ชนิดพิเศษที่เรียกว่าประเภทการอ้างอิง พอยน์เตอร์ประเภทการอ้างอิงนั้นถูกอ้างถึงในโปรแกรมย่อยโดยปริยาย แต่ความหมายของมันก็เป็นแบบ pass-by-reference

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

สำหรับข้อมูลเพิ่มเติมโปรดดูที่หนังสือแนวคิดของการเขียนโปรแกรมภาษาโดย Robert Sebesta, 10th Ed, บทที่ 9

คุณไม่ได้ผ่าน int โดยการอ้างอิงคุณจะผ่านตัวชี้ไปยังค่า int ไวยากรณ์ที่แตกต่างความหมายเดียวกัน

ใน C เพื่อผ่านการอ้างอิงคุณใช้ที่อยู่ของผู้ประกอบการ&ซึ่งควรใช้กับตัวแปร แต่ในกรณีของคุณเนื่องจากคุณใช้ตัวแปรตัวชี้pคุณไม่จำเป็นต้องนำหน้าด้วยตัวดำเนินการที่อยู่ของ ก็จะได้รับความจริงถ้าคุณใช้เป็นพารามิเตอร์:&if(&i)

คุณยังสามารถเพิ่มสิ่งนี้เพื่ออ้างอิงpและดูว่าค่านั้นตรงกับi:

printf("p=%d \n",*p);

พอยน์เตอร์และการอ้างอิงเป็นสอง Thigngs ที่แตกต่างกัน

สองสิ่งที่ฉันไม่เคยเห็นมาก่อน

ตัวชี้คือที่อยู่ของบางสิ่งบางอย่าง ตัวชี้สามารถจัดเก็บและคัดลอกเหมือนตัวแปรอื่น ๆ มันจึงมีขนาด

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

ด้วยการอ้างอิงคุณไม่มีปัญหากับพอยน์เตอร์เช่นการจัดการความเป็นเจ้าของการตรวจสอบโมฆะการยกเลิกการอ้างอิงในการใช้งาน

'ส่งผ่านการอ้างอิง' (โดยใช้ตัวชี้) อยู่ใน C ตั้งแต่ต้น ทำไมคุณถึงคิดว่ามันไม่

ฉันคิดว่า C อันที่จริงรองรับการอ้างอิงผ่าน

ภาษาส่วนใหญ่ต้องการน้ำตาลซินแทคติกเพื่อส่งต่อโดยอ้างอิงแทนค่า (ตัวอย่างเช่น C ++ ต้องการ & ในการประกาศพารามิเตอร์)

C ยังต้องใช้น้ำตาลซินแทคติกสำหรับสิ่งนี้ เป็น * ในการประกาศชนิดพารามิเตอร์และ & บนอาร์กิวเมนต์ ดังนั้น * และ & คือไวยากรณ์ C สำหรับการส่งผ่านโดยการอ้างอิง

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

แต่ตอนนี้มา C # ซึ่งไม่สนับสนุนโดยผ่านการอ้างอิงและต้องใช้น้ำตาลประโยคบนทั้งพารามิเตอร์และโต้แย้งด้าน

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

อาร์กิวเมนต์ที่เหลืออยู่เพียงอย่างเดียวคือการส่งต่อโดยอ้างอิงใน C ไม่ใช่คุณลักษณะแบบเสาหิน แต่รวมสองคุณลักษณะที่มีอยู่ (รับการโต้แย้งโดย & คาดว่า ref จะพิมพ์ด้วย *.) ตัวอย่างเช่น C # ต้องการองค์ประกอบสองประโยค แต่ไม่สามารถใช้งานได้หากไม่มีกันและกัน

เห็นได้ชัดว่านี่เป็นข้อโต้แย้งที่อันตรายทำให้มีคุณสมบัติอื่น ๆ มากมายในภาษาที่ประกอบด้วยคุณสมบัติอื่น ๆ (เช่นการสนับสนุนสตริงใน C ++)

สิ่งที่คุณกำลังทำคือการส่งผ่านค่าไม่ผ่านการอ้างอิง เนื่องจากคุณกำลังส่งค่าของตัวแปร 'p' ไปยังฟังก์ชัน 'f' (ใน main เป็น f (p);)

โปรแกรมเดียวกันใน C พร้อม pass โดยการอ้างอิงจะมีลักษณะ (!!! โปรแกรมนี้ให้ 2 ข้อผิดพลาดเนื่องจาก C ไม่รองรับการอ้างอิงผ่าน)

#include <stdio.h>

void f(int &j) {    //j is reference variable to i same as int &j = i
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

เอาท์พุท: -

3:12: ข้อผิดพลาด: คาดว่า ';', ',' หรือ ')' ก่อนหน้าโทเค็น '&'
             เป็นโมฆะ f (int & j);
                        ^
9: 3: คำเตือน: การประกาศโดยนัยของฟังก์ชัน 'f'
               f (ก);
               ^