C++引用的意义与引用的本质
1、引用的意义
引用作为变量别名
而存在,因此在一些场合可以替代指针,引用相对于指针来说具有更好的可读性和实用性
// swap函数的实现对比 void swap(int& a, int& b) { int t = a; a = b; b = t; } void swap(int* a, int* b) { int t = *a; *a = *b; *b = t; }
注意:函数中的引用形参不需要进行初始化,初始化是在调用的时候完成的
2、特殊的引用
const引用
在C++中可以声明const
引用,具体用法如下:
const Type& name = var;
const
引用让变量拥有只读属性,这个只读属性是针对当前的这个别名,变量是可以通过其它方式进行修改
int a = 4; // a是一个变量 const int & b = a; // b是a的一个引用,但是b具有只读属性 int * p = (int *)&b; // p = &a b = 5; // err, 引用b 被const修饰,b是一个只读变量 a = 6; // ok printf("a = %d\n", a); *p = 5; // ok printf("a = %d\n", a);
当使用常量对const
引用进行初始化时,C++编译器会为常量值分配空间,并将引用名作为这段空间的别名
#include <stdio.h> void Example() { printf("Example:\n"); int a = 4; const int& b = a; int* p = (int*)&b; //b = 5; // b *p = 5; printf("a = %d\n", a); printf("b = %d\n", b); } void Demo() { printf("Demo:\n"); const int& c = 1; int* p = (int*)&c; //c = 5; *p = 5; printf("c = %d\n", c); } int main(int argc, char *argv[]) { Example(); printf("\n"); Demo(); return 0; }
结论:使用常量对
const
引用初始化后将产生一个只读变量
问题:引用有自己的存储空间吗?
struct TRef { char& r; } printf("sizeof(TRef) = %d\n, sizeof(TRef));
验证程序:
#include <stdio.h> struct TRef { char& r; // 字符类型引用 }; int main(int argc, char *argv[]) { char c = 'c'; char & rc = c; TRef ref = { c }; // 用C进行初始化, TRef.r 就是 c的别名了 printf("sizeof(char&) = %d\n", sizeof(char&)); // char引用的大小,引用即变量本身,求所对应的变量本身的大小,即sizeof(char) = 1 printf("sizeof(rc) = %d\n", sizeof(rc)); // rc是一个引用,即sizeof(c) = 1 printf("sizeof(TRef) = %d\n", sizeof(TRef)); // sizeof(TRef) = 4 printf("sizeof(ref.r) = %d\n", sizeof(ref.r)); // TRef.r是 c的别名,sizeof(c) = 1 // sizeof(TRef) = 4 // 指针变量本身也是占4个字节 // 引用和指针的关系 return 0; }
3、引用的本质
引用在C++中的内部实现是一个指针常量
注意:
1、C++编译器在编译过程中用 指针常量 作为引用的内部实现,因此引用所占用的空间大小于指针相同
2、从使用的角度,引用只是一个别名,C++为了使用性而隐藏了引用的存储空间这一细节。
#include <stdio.h> struct TRef { char* before; // 4字节 char& ref; // 4字节 char* after; // 4字节 }; int main(int argc, char* argv[]) { char a = 'a'; char& b = a; char c = 'c'; TRef r = {&a, b, &c}; printf("sizeof(r) = %d\n", sizeof(r)); // sizeof(r) = 12 printf("sizeof(r.before) = %d\n", sizeof(r.before)); // sizeof(r.before) = 4 printf("sizeof(r.after) = %d\n", sizeof(r.after)); // sizeof(r.after) = 4 printf("&r.before = %p\n", &r.before); // &r.before = 0xbuf8a300c printf("&r.after = %p\n", &r.after); // &r.after = 0xbuf8a3014 /* 0xbuf8a3014 - 0xbuf8a300c = 8 before占了4个字节,所以ref也是占4个字节 */ return 0; }
引用的意义:
C++中的引用旨在大多数的情况下替代指针
功能性:可以满足多数需要使用指针的场合
安全性:可以避开由于指针操作不当带来的内存错误
操作性:简单易用,又不失功能强大
但是
引用可以在大多数情况下避免内存的错误,函数返回局部变量的引用,就没法避免了
#include <stdio.h> int& demo() { int d = 0; printf("demo: d = %d\n", d); return d; // 实际上是返回了局部变量的地址,局部变量函数结束就销毁了,返回错误 } int& func() { static int s = 0; printf("func: s = %d\n", s); return s; // 返回静态局部变量的地址,静态局部变量存储在全局区,函数结束生命周期还在,返回成功 } int main(int argc, char* argv[]) { int& rd = demo(); // rd 成为demo里面返回的局部变量d的别名,出现警告,但是通过编译 int& rs = func(); // rs 成为静态局部变量 s 的别名 printf("\n"); printf("main: rd = %d\n", rd); // rd = 13209588,rd代表的是一个不存在的变量,现在是一个野指针 printf("main: rs = %d\n", rs); // rs = 0 printf("\n"); rd = 10; rs = 11; // 通过rs改变了静态局部变量s的值 demo(); // d = 10 func(); // s = 11 printf("\n"); printf("main: rd = %d\n", rd); // rd = 13209588 printf("main: rs = %d\n", rs); // rs = 11 printf("\n"); return 0; }
4、小结
引用作为变量别名而存在旨在代替指针
const
引用可以使得变量具有只读属性引用在编译器内部使用指针常量实现
引用的最终本质为指针
引用可以尽可能地避开内存错误
相关文章:
Atas ialah kandungan terperinci C++引用的意义与引用的本质. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Alat AI Hot

Undresser.AI Undress
Apl berkuasa AI untuk mencipta foto bogel yang realistik

AI Clothes Remover
Alat AI dalam talian untuk mengeluarkan pakaian daripada foto.

Undress AI Tool
Gambar buka pakaian secara percuma

Clothoff.io
Penyingkiran pakaian AI

AI Hentai Generator
Menjana ai hentai secara percuma.

Artikel Panas

Alat panas

Notepad++7.3.1
Editor kod yang mudah digunakan dan percuma

SublimeText3 versi Cina
Versi Cina, sangat mudah digunakan

Hantar Studio 13.0.1
Persekitaran pembangunan bersepadu PHP yang berkuasa

Dreamweaver CS6
Alat pembangunan web visual

SublimeText3 versi Mac
Perisian penyuntingan kod peringkat Tuhan (SublimeText3)

Topik panas



Langkah-langkah untuk melaksanakan corak strategi dalam C++ adalah seperti berikut: tentukan antara muka strategi dan isytiharkan kaedah yang perlu dilaksanakan. Buat kelas strategi khusus, laksanakan antara muka masing-masing dan sediakan algoritma yang berbeza. Gunakan kelas konteks untuk memegang rujukan kepada kelas strategi konkrit dan melaksanakan operasi melaluinya.

Warisan templat C++ membenarkan kelas terbitan templat menggunakan semula kod dan kefungsian templat kelas asas, yang sesuai untuk mencipta kelas dengan logik teras yang sama tetapi gelagat khusus yang berbeza. Sintaks warisan templat ialah: templateclassDerived:publicBase{}. Contoh: templateclassBase{};templateclassDerived:publicBase{};. Kes praktikal: Mencipta kelas terbitan Derived, mewarisi fungsi mengira Base kelas asas, dan menambah kaedah printCount untuk mencetak kiraan semasa.

Punca dan penyelesaian untuk kesilapan Apabila menggunakan PECL untuk memasang sambungan dalam persekitaran Docker Apabila menggunakan persekitaran Docker, kami sering menemui beberapa sakit kepala ...

Dalam C, jenis char digunakan dalam rentetan: 1. Simpan satu watak; 2. Gunakan array untuk mewakili rentetan dan berakhir dengan terminator null; 3. Beroperasi melalui fungsi operasi rentetan; 4. Baca atau output rentetan dari papan kekunci.

Dalam C++ berbilang benang, pengendalian pengecualian dilaksanakan melalui mekanisme std::promise dan std::future: gunakan objek promise untuk merekodkan pengecualian dalam utas yang membuang pengecualian. Gunakan objek masa hadapan untuk menyemak pengecualian dalam urutan yang menerima pengecualian. Kes praktikal menunjukkan cara menggunakan janji dan niaga hadapan untuk menangkap dan mengendalikan pengecualian dalam urutan yang berbeza.

Multithreading dalam bahasa dapat meningkatkan kecekapan program. Terdapat empat cara utama untuk melaksanakan multithreading dalam bahasa C: Buat proses bebas: Buat pelbagai proses berjalan secara bebas, setiap proses mempunyai ruang ingatan sendiri. Pseudo-Multithreading: Buat pelbagai aliran pelaksanaan dalam proses yang berkongsi ruang memori yang sama dan laksanakan secara bergantian. Perpustakaan multi-threaded: Gunakan perpustakaan berbilang threaded seperti PTHREADS untuk membuat dan mengurus benang, menyediakan fungsi operasi benang yang kaya. Coroutine: Pelaksanaan pelbagai threaded ringan yang membahagikan tugas menjadi subtask kecil dan melaksanakannya pada gilirannya.

Pengiraan C35 pada dasarnya adalah matematik gabungan, yang mewakili bilangan kombinasi yang dipilih dari 3 dari 5 elemen. Formula pengiraan ialah C53 = 5! / (3! * 2!), Yang boleh dikira secara langsung oleh gelung untuk meningkatkan kecekapan dan mengelakkan limpahan. Di samping itu, memahami sifat kombinasi dan menguasai kaedah pengiraan yang cekap adalah penting untuk menyelesaikan banyak masalah dalam bidang statistik kebarangkalian, kriptografi, reka bentuk algoritma, dll.

Teknik pengoptimuman untuk pengurusan memori C++ termasuk: menggunakan penunjuk pintar (RAII), mengurangkan peruntukan yang kerap, mengelakkan salinan yang tidak perlu, menggunakan API peringkat rendah (dengan berhati-hati), dan menganalisis penggunaan memori. Melalui teknik ini, seperti menggunakan penunjuk pintar dan caching dalam aplikasi pemprosesan imej, penggunaan memori dan prestasi boleh dioptimumkan dengan ketara.
