Declaring a variable as a reference

Declaring a variable as a reference rather than a normal variable simply entails appending an ampersand to the type name, such as this "reference to an int"
Did you notice the "...."? (Probably, right? After all, it's 25% of the example.) When a reference is created, you must tell it which variable it will become an alias for. After you create the reference, whenever you use the variable, you can just treat it as though it were a regular integer variable. But when you create it, you must initialize it with another variable, whose address it will keep around behind the scenes to allow you to use it to modify that variable.
In a way, this is similar to having a pointer that always points to the same thing. One key difference is that references do not require dereferencing in the same way that pointers do; you just treat them as normal variables. A second difference is that when you create a reference to a variable, you need not do anything special to get the memory address. The compiler figures this out for you:
Functions taking References Parameters
Here's a simple example of setting up a function to take an argument "by reference", implementing the swap function:
Both arguments are passed "by reference"--the caller of the function need not even be aware of it:
After the swap, a will be 3 and b will be 2. The fact that references require no extra work can lead to confusion at times when variables magically change after being passed into a function. Bjarne Stroustrup suggests that for arguments that the function is expected to change, using a pointer instead of a reference helps make this clear--pointers require that the caller explicitly pass in the memory address.
Efficiency Gains
You might wonder why you would ever want to use references other than to change the value--well, the answer is that passing by reference means that the variable need not be copied, yet it can still be passed into a function without doing anything special. This gives you the most bang for your buck when working with classes. If you want to pass a class into a function, it almost always makes sense for the function to take the class "by reference"--but generally, you want to use a const reference.
This might look something like this:
The great thing about using const references is that you can be sure that the variable isn't modified, so you can immediately change all of your functions that take large objects--no need to make a copy anymore. And even you were conscientious and used pointers to pass around large objects, using references in the future can still make your code that much cleaner.
References and Safety

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

ประกาศตัวแปรเป็นการอ้างอิงแทนที่เป็นตัวแปรปกติเพียงแค่มีการผนวกเครื่องหมาย ampersand เป็นชื่อชนิด เช่นนี้ "อ้างอิงไป int"คุณเห็นการ "..." (อาจ ขวา After all มันเป็น 25% ของตัวอย่าง) เมื่อสร้างการอ้างอิง คุณต้องสั่งตัวแปรที่จะใช้นามแฝงในการ หลังจากที่คุณสร้างการอ้างอิง เมื่อคุณใช้ตัวแปร คุณสามารถเพียงแค่รักษามันเหมือนว่ามันมีตัวแปรจำนวนเต็มปกติ แต่เมื่อคุณสร้าง คุณต้องเริ่มต้นมัน มีตัวแปรอื่น ที่อยู่จะให้สถานเบื้องหลังเพื่อให้คุณสามารถใช้เพื่อปรับเปลี่ยนตัวแปรนั้น วิธี อยู่กับเสมอไปเหมือนมี ความแตกต่างที่สำคัญหนึ่งที่อ้างอิงไม่ต้อง dereferencing แบบเดียวกับที่ตัวชี้ทำ คุณเพียงคิดว่าเป็นตัวแปรปกติ ความแตกต่างสองคือ ว่า เมื่อคุณสร้างการอ้างอิงตัวแปร คุณต้องไม่ทำอะไรเป็นพิเศษจะได้รับอยู่หน่วยความจำ คอมไพเลอร์ตัวเลขนี้ออกมาสำหรับคุณ:ฟังก์ชันการอ้างอิงพารามิเตอร์นี่คือตัวอย่างง่าย ๆ เช่นการตั้งค่าฟังก์ชันจะใช้อาร์กิวเมนต์ "โดยอ้างอิง" ใช้ฟังก์ชัน swap:อาร์กิวเมนต์ทั้งสองจะถูกส่งผ่าน "โดยการอ้างอิง" - ผู้เรียกฟังก์ชันไม่ได้ต้องทราบว่า:หลังจากสลับ จะเป็น 3 และ b จะเป็น 2 ความจริงที่อ้างอิงต้องไม่เพิ่มเติมอาจทำให้สับสนบางครั้งเมื่อตัวแปรเปลี่ยนแปลงหลังจากการผ่านเข้าสู่ฟังก์ชันทำให้แขก Bjarne Stroustrup แนะนำว่า สำหรับอาร์กิวเมนต์ที่ฟังก์ชันคาดว่าจะเปลี่ยนแปลง การใช้ตัวชี้แทนการอ้างอิง ช่วยให้นี้ชัดเจน - ชี้ต้องให้โทรอย่างชัดเจนผ่านในอยู่ของหน่วยความจำกำไรประสิทธิภาพคุณอาจสงสัยว่า ทำไมคุณเคยต้องการใช้การอ้างอิงอื่นเพื่อเปลี่ยนค่า - ดี คำตอบคือที่ผ่าน โดยการอ้างอิงหมายความว่าตัวแปรต้องไม่คัดลอก แต่มันสามารถยังสามารถผ่านเข้าสู่ฟังก์ชันโดยไม่ทำอะไรเป็นพิเศษ นี้ให้บางสุดนันทนาการเมื่อทำงานกับชั้น ถ้าคุณต้องการผ่านชั้นเรียนลงในฟังก์ชัน มันเกือบตลอดเวลาทำให้รู้สึกสำหรับฟังก์ชันที่จะเรียน "โดยอ้างอิง" - แต่โดยทั่วไปแล้ว คุณต้องการใช้การอ้างอิงค่าคง นี้อาจดูเหมือน:สิ่งดีเกี่ยวกับการใช้การอ้างอิงค่าคงเป็นที่ที่คุณสามารถมั่นใจว่า ไม่ได้ปรับเปลี่ยนตัวแปร เพื่อให้คุณได้ทันทีสามารถเปลี่ยนทั้งหมดของฟังก์ชันที่มีวัตถุขนาดใหญ่ - ไม่จำเป็นต้องทำสำเนาอีกต่อไป แม้คุณมีคุณธรรม และใช้ตัวชี้ผ่านรอบ ๆ วัตถุขนาดใหญ่ ใช้อ้างอิงในอนาคตยังคงสามารถทำของที่สะอาดมากขึ้นอ้างอิงและความปลอดภัย

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

ประกาศตัวแปรเป็นข้อมูลอ้างอิงมากกว่าตัวแปรปกติเพียง entails ท้ายเครื่องหมายกับชื่อประเภทเช่นนี้ "การอ้างอิงถึง int"
คุณไม่แจ้งให้ทราบล่วงหน้า ".... "? (อาจใช่มั้ย? หลังจากที่ทั้งหมดจะเป็น 25% ของตัวอย่าง.) เมื่อมีการสร้างการอ้างอิงคุณต้องบอกว่าตัวแปรที่มันจะกลายเป็นนามแฝงสำหรับ หลังจากที่คุณสร้างอ้างอิงเมื่อใดก็ตามที่คุณใช้ตัวแปรคุณก็สามารถรักษามันราวกับว่ามันเป็นตัวแปรจำนวนเต็มปกติ แต่เมื่อคุณสร้างมันขึ้นมาคุณจะต้องเริ่มต้นกับตัวแปรอื่นที่มีอยู่ก็จะเก็บไปรอบ ๆ อยู่เบื้องหลังเพื่อให้คุณสามารถใช้มันในการปรับเปลี่ยนตัวแปรที่.
ในทางนี้จะคล้ายกับมีตัวชี้ที่มักจะชี้ไปที่ สิ่งเดียวกัน. หนึ่งความแตกต่างที่สำคัญคือการอ้างอิงที่ไม่จำเป็นต้อง dereferencing ในลักษณะเดียวกับที่ตัวชี้ทำ; คุณเพียงแค่รักษาพวกเขาเป็นตัวแปรตามปกติ ความแตกต่างที่สองคือเมื่อคุณสร้างการอ้างอิงถึงตัวแปรที่คุณไม่จำเป็นต้องทำอะไรเป็นพิเศษที่จะได้รับที่อยู่ในหน่วยความจำ ตัวเลขคอมไพเลอร์นี้สำหรับคุณ:
ฟังก์ชั่นการใช้พารามิเตอร์อ้างอิงนี่คือตัวอย่างง่ายๆของการตั้งค่าฟังก์ชั่นที่จะใช้อาร์กิวเมนต์ "โดยอ้างอิง" การใช้ฟังก์ชั่นการแลก: ข้อโต้แย้งทั้งสองจะถูกส่งผ่าน "โดยอ้างอิง" - โทรของฟังก์ชัน ไม่จำเป็นต้องได้ตระหนักถึงมันหลังจากการแลกเปลี่ยนที่จะเป็นที่3 และข 2. จะเป็นความจริงที่ว่าไม่จำเป็นต้องมีการอ้างอิงการทำงานพิเศษสามารถนำไปสู่ความสับสนในช่วงเวลาที่น่าอัศจรรย์ตัวแปรเปลี่ยนไปหลังจากที่ถูกส่งเข้ามาในฟังก์ชั่น Bjarne Stroustrup แสดงให้เห็นว่าสำหรับข้อโต้แย้งที่ฟังก์ชั่นที่คาดว่าจะมีการเปลี่ยนแปลงโดยใช้ตัวชี้แทนการอ้างอิงจะช่วยทำให้เรื่องนี้ชัดเจน -. ชี้จำเป็นต้องให้ผู้ที่โทรมาอย่างชัดเจนผ่านที่อยู่ในหน่วยความจำเพิ่มประสิทธิภาพคุณอาจสงสัยว่าทำไมคุณเคยต้องการที่จะใช้อ้างอิงอื่น ๆ กว่าที่จะเปลี่ยนค่า - ดีคำตอบคือที่ผ่านโดยการอ้างอิงหมายความว่าตัวแปรไม่จำเป็นต้องคัดลอก แต่ก็ยังสามารถผ่านเข้าสู่ฟังก์ชั่นโดยไม่ต้องทำอะไรเป็นพิเศษ นี้จะช่วยให้คุณสูงสุดสำหรับเจ้าชู้ของคุณเมื่อทำงานกับการเรียน หากคุณต้องการที่จะผ่านระดับในการทำงานก็มักจะทำให้รู้สึกสำหรับฟังก์ชั่นที่จะใช้เรียน "โดยอ้างอิง" - แต่โดยทั่วไปคุณต้องการที่จะใช้การอ้างอิง const. นี้อาจมีลักษณะบางอย่างเช่นนี้สิ่งที่ดีเกี่ยวกับการใช้การอ้างอิง const คือการที่คุณสามารถมั่นใจได้ว่าตัวแปรที่ไม่ได้มีการปรับเปลี่ยนเพื่อให้คุณได้ทันทีสามารถเปลี่ยนฟังก์ชั่นทั้งหมดของคุณที่ใช้วัตถุขนาดใหญ่ - ไม่จำเป็นต้องทำสำเนาอีกต่อไป และแม้ว่าคุณขยันขันแข็งและใช้ตัวชี้ไปยังวัตถุขนาดใหญ่ผ่านไปรอบ ๆ โดยใช้การอ้างอิงในอนาคตยังสามารถสร้างรหัสที่ทำความสะอาดมาก. อ้างอิงและความปลอดภัย

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

ประกาศตัวแปรอ้างอิงมากกว่าตัวแปรปกติ เพียงแค่ใช้ต่อท้ายที่ไทยแลนด์เซอร์กิตกับชื่อประเภท เช่น " อ้างอิง 1 "
เธอสังเกตเห็น " . . . . . . . " ( อาจจะใช่มั้ย ? หลังจากทั้งหมด เป็น 25 % ของตัวอย่าง เมื่ออ้างอิงจะถูกสร้างขึ้น คุณต้องบอกตัวแปรซึ่งจะเป็นนามแฝงสำหรับ หลังจากที่คุณสร้างการอ้างอิงเมื่อใดก็ตามที่คุณใช้ตัวแปรคุณสามารถทำกับมันราวกับมันเป็นตัวแปรจำนวนเต็มปกติ แต่เมื่อคุณสร้างมันคุณจะต้องเริ่มต้นด้วยตัวแปรอื่น ซึ่งจะทำให้รอบ ๆที่อยู่เบื้องหลังเพื่อให้คุณสามารถใช้มันเพื่อแก้ไขตัวแปร
ในวิธีนี้จะคล้ายกับการชี้ที่จุดเดียวกันหนึ่งความแตกต่างที่สำคัญคือการที่อ้างอิงไม่ต้อง dereferencing ในทางเดียวกันว่า ชี้ทำ ; คุณเพียงแค่รักษาพวกเขาเป็นตัวแปรปกติ ความแตกต่างที่สองคือเมื่อคุณสร้างการอ้างอิงถึงตัวแปรที่คุณไม่ต้องทำอะไรพิเศษจะได้รับหน่วยความจำที่อยู่ คอมไพเลอร์ตัวเลขนี้ให้คุณฟังก์ชั่นการอ้างอิงค่า

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

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

อ้างอิง .