Trung tâm cá nhân
sách gpt4 ăn đã đi

Phân tích tài liệu tham khảo C++

In lại Tác giả: qq735679552 Thời gian cập nhật: 27-09-2022 22:32:09 25 4
mua khóa gpt4 giày nike

CFSDN nhấn mạnh vào giá trị tạo ra nguồn mở và chúng tôi cam kết xây dựng nền tảng chia sẻ tài nguyên để mọi nhân viên CNTT có thể tìm thấy thế giới tuyệt vời của bạn tại đây.

Bài viết trên blog CFSDN này phân tích các tài liệu tham khảo về C++ được tác giả sưu tầm và biên soạn. Nếu các bạn quan tâm đến bài viết này thì nhớ like nhé.

giới thiệu

Tôi chọn viết về tài liệu tham khảo bằng C++ vì tôi cảm thấy rằng hầu hết mọi người đều hiểu sai tài liệu tham khảo. Lý do khiến tôi cảm thấy như vậy là vì tôi đã thực hiện nhiều cuộc phỏng vấn về C++ và hiếm khi nhận được câu trả lời chính xác về tài liệu tham khảo về C++ từ những người được phỏng vấn.

Vậy trích dẫn có ý nghĩa gì trong C++? Thông thường, một tham chiếu được coi là bí danh cho một biến được tham chiếu và tôi ghét ý tưởng các tham chiếu trong C++ được xác định là bí danh cho các biến. Trong bài viết này, tôi sẽ cố gắng giải thích rõ ràng rằng không có gì gọi là bí danh trong C++.

lý lịch

Trong C/C++, việc truy cập một biến chỉ có thể được truy cập theo hai cách, truyền nó hoặc truy vấn nó. Hai cách là:

1. Truy cập/chuyển các biến theo giá trị.

2. Truy cập/truyền biến theo địa chỉ – Phương thức này là một con trỏ.

Không có cách thứ ba để truy cập và chuyển các giá trị biến. Biến tham chiếu là biến con trỏ, cũng có không gian bộ nhớ. Điều quan trọng nhất là tham chiếu là một con trỏ sẽ được trình biên dịch tự động hủy đăng ký. Có khó tin không?

Dưới đây là một mã C++ đơn giản sử dụng tài liệu tham khảo.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include  
số nguyên chủ yếu() 
{ 
     số nguyên tôi = 10;   // Một biến số nguyên đơn giản 
     số nguyên &j = tôi;   // Tham chiếu đến biến i 
     j++;   // Tăng j sẽ tăng cả i và j. 
     // kiểm tra bằng cách in ra giá trị của i và j 
     cout<< i << j < // nên in 11 11 
     // Bây giờ hãy thử in địa chỉ của cả hai biến i và j 
     cout<< &i << &j <
     // thật ngạc nhiên là cả hai đều in cùng một địa chỉ và khiến chúng ta cảm thấy rằng chúng là 
     // bí danh cho cùng một vị trí bộ nhớ. 
     // Trong ví dụ dưới đây chúng ta sẽ thấy thực tế là gì 
     trở lại 0; 
}

Tài liệu tham khảo thực sự là con trỏ không đổi trong C++. Biểu thức int &i = j; sẽ được trình biên dịch chuyển đổi thành int *const i = &j; và lý do tại sao tham chiếu cần được khởi tạo là vì biến kiểu const phải được khởi tạo và con trỏ này cũng phải trỏ đến một cái gì đó. Tiếp theo, chúng ta tập trung lại vào đoạn mã trên và thay thế tham chiếu bằng cú pháp của trình biên dịch.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
#include  
số nguyên chủ yếu() 
{ 
     số nguyên tôi = 10;            // Một biến số nguyên đơn giản 
     số nguyên * hằng số j = &i;     // Tham chiếu đến biến i 
     (*j)++;                // Tăng j. Vì các biến tham chiếu là  
                           // tự động hủy tham chiếu bởi trình biên dịch 
     // kiểm tra bằng cách in ra giá trị của i và j 
     cout<< i << *j < // nên in 11 11 
     // A * được thêm vào trước j vì nó từng là biến tham chiếu 
     // và nó sẽ tự động được hủy tham chiếu. 
     trở lại 0; 
}

Chắc hẳn bạn đọc đang thắc mắc tại sao đoạn mã trên lại bỏ qua bước in địa chỉ. Một số lời giải thích là cần thiết ở đây. Bởi vì khi một biến được tham chiếu, nó sẽ được trình biên dịch tự động hủy tham chiếu, do đó, một câu lệnh như cout << &j << endl; sẽ được trình biên dịch chuyển đổi thành một câu lệnh cout << &*j << endl; * sẽ bù đắp cho nhau, câu này trở nên vô nghĩa, và giá trị j được in ra bởi cout chính là địa chỉ của i, vì câu định nghĩa của nó là int *const j = &i,

Vì vậy, câu lệnh cout << &i << &j << endl; trở thành cout << &i << &*j << endl; Đây là lý do tại sao khi chúng ta in các biến thông thường và biến tham chiếu, đầu ra có cùng một địa chỉ.

Đây là một đoạn mã phức tạp hơn để xem cách hoạt động của các tham chiếu theo tầng.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include  
số nguyên chủ yếu() 
{ 
     số nguyên tôi = 10; // Một biến số nguyên đơn giản 
     số nguyên &j = tôi; // Tham chiếu đến biến 
     // Bây giờ chúng ta cũng có thể tạo tham chiếu tới biến tham chiếu.  
     số nguyên &k = j; // Tham chiếu đến một biến tham chiếu 
     // Tương tự như vậy chúng ta cũng có thể tạo một tham chiếu khác đến biến tham chiếu k 
     số nguyên &l = k; // Một tham chiếu đến một tham chiếu đến một biến tham chiếu. 
     // Bây giờ nếu chúng ta tăng bất kỳ một trong số chúng thì hiệu ứng sẽ hiển thị trên tất cả 
     // biến. 
     // In giá trị gốc đầu tiên 
     // Bản in phải là 10,10,10,10 
     cout<< tôi <<  ","  << j <<  ","  << k <<  ","  << l << kết thúc; 
     // tăng biến j 
     j++;  
     // Số in phải là 11,11,11,11 
     cout<< tôi <<  ","  << j <<  ","  << k <<  ","  << l << kết thúc; 
     // tăng biến k 
     k++; 
     // Số in phải là 12,12,12,12 
     cout<< tôi <<  ","  << j <<  ","  << k <<  ","  << l << kết thúc; 
     // tăng biến l 
     l++; 
     // Số in phải là 13,13,13,13 
     cout<< tôi <<  ","  << j <<  ","  << k <<  ","  << l << kết thúc; 
     trở lại 0; 
}

Đoạn mã sau là đoạn mã sau khi thay thế các tham chiếu trong đoạn mã trên, có nghĩa là chúng ta không dựa vào chức năng thay thế tự động của trình biên dịch mà thay thế thủ công cũng có thể đạt được mục tiêu tương tự.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include  
số nguyên chủ yếu() 
{ 
     số nguyên tôi = 10;         // Một biến số nguyên đơn giản 
     số nguyên * hằng số j = &i;     // Tham chiếu đến biến 
     // Biến j sẽ giữ địa chỉ của i 
     // Bây giờ chúng ta cũng có thể tạo tham chiếu tới biến tham chiếu.  
     số nguyên * hằng số k = &*j;     // Tham chiếu đến một biến tham chiếu 
     // Biến k cũng sẽ giữ địa chỉ của i vì j  
     // là một biến tham chiếu và  
     // nó được tự động hủy tham chiếu. Sau khi & và * hủy lẫn nhau  
     // k sẽ giữ giá trị của 
     // j mà nó không là gì ngoài địa chỉ của i 
     // Tương tự như vậy chúng ta cũng có thể tạo một tham chiếu khác đến biến tham chiếu k 
     số nguyên * hằng số l = &*k;     // Một tham chiếu đến một tham chiếu đến một biến tham chiếu. 
     // Biến l cũng sẽ giữ địa chỉ của i vì k giữ địa chỉ của i sau 
     // & và * triệt tiêu lẫn nhau. 
     // vì vậy chúng ta đã thấy rằng tất cả các biến tham chiếu thực sự sẽ giữ nguyên 
     // địa chỉ biến. 
     // Bây giờ nếu chúng ta tăng bất kỳ một trong số chúng thì hiệu ứng sẽ hiển thị trên tất cả 
     // biến. 
     // Đầu tiên in các giá trị gốc. Các biến tham chiếu sẽ có tiền tố * vì  
     // các biến này sẽ tự động được hủy tham chiếu. 
     // Bản in phải là 10,10,10,10 
     cout<< tôi <<  ","  << *j <<  ","  << *k <<  ","  << *l <
     // tăng biến j 
     (*j)++;  
     // Số in phải là 11,11,11,11 
     cout<< tôi <<  ","  << *j <<  ","  << *k <<  ","  << *l <
     // tăng biến k 
     (*k)++; 
     // Số in phải là 12,12,12,12 
     cout<< tôi <<  ","  << *j <<  ","  << *k <<  ","  << *l <
     // tăng biến l 
     (*l)++; 
     // Số in phải là 13,13,13,13 
     lệnh << tôi <<  ","  << *j <<  ","  << *k <<  ","  << *l <
     trở lại 0; 
}

Chúng tôi có thể chứng minh thông qua đoạn mã sau rằng tham chiếu C++ không phải là bí danh của Shenma và nó cũng sẽ chiếm dung lượng bộ nhớ.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
#include  
lớp học Bài kiểm tra 
{ 
     số nguyên &Tôi;   // số nguyên *const i; 
     số nguyên &j;   // số nguyên *const j; 
     số nguyên &k;   // số nguyên *const k;  
}; 
số nguyên chủ yếu() 
{     
     // Điều này sẽ in ra 12 tức là kích thước của 3 con trỏ 
     cout<<  "kích thước của lớp Test = "  <<   kích thước của ( lớp học Kiểm tra) <
     trở lại 0; 
}

Tóm lại

Tôi hy vọng bài viết này giải thích mọi thứ về tham chiếu C++. Tuy nhiên, tôi muốn chỉ ra rằng tiêu chuẩn C++ không giải thích cách trình biên dịch thực hiện hành vi của tham chiếu. Vì vậy, việc triển khai phụ thuộc vào trình biên dịch và trong hầu hết các trường hợp, tham chiếu được triển khai dưới dạng con trỏ const.

Mã tham chiếu hỗ trợ cơ chế hàm ảo C++.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include  
lớp học MỘT 
{ 
công cộng : 
          ảo vô hiệu in() { cout<< "MỘT.." <
}; 
lớp học B: công cộng MỘT 
{ 
công cộng : 
          ảo vô hiệu in() { cout<< "B.." <
}; 
   
lớp học C : công cộng B 
{ 
công cộng : 
          ảo vô hiệu in() { cout<< "C.." <
}; 
số nguyên chủ yếu() 
{ 
          C1; 
          A &a1 = c1; 
          a1. in(); // in C 
          A a2 = c1; 
          a2.print(); // in A 
          trở lại 0; 
}

Đoạn mã trên sử dụng các tham chiếu để hỗ trợ cơ chế hàm ảo. Nếu tham chiếu chỉ là bí danh, làm cách nào để triển khai cơ chế hàm ảo? Thông tin động mà cơ chế hàm ảo yêu cầu chỉ có thể đạt được thông qua con trỏ, vì vậy nó minh họa thêm rằng tham chiếu thực sự là con trỏ const.

Trên đây là nội dung chi tiết về phân tích tài liệu tham khảo C++. Để biết thêm thông tin về tài liệu tham khảo C++, vui lòng theo dõi các bài viết liên quan khác của tôi! .

Liên kết gốc: https://www.cnblogs.com/lsgxeva/p/7785261.html.

Cuối cùng, bài viết về phân tích tài liệu tham khảo C++ này kết thúc tại đây. Nếu bạn muốn biết thêm về phân tích tài liệu tham khảo C++, vui lòng tìm kiếm các bài viết về CFSDN hoặc tiếp tục duyệt các bài viết liên quan. Tôi hy vọng bạn sẽ ủng hộ blog của tôi trong tương lai! .

25 4 0
Đề xuất bài viết: Hãy nói về cảm giác xếp hàng mua vắc xin ngày xưa tôi không biết trân trọng vắc xin.
Đề xuất bài viết: Hàm đệ quy không một chiều của Python trả về tất cả kết quả như thế nào?
Đề xuất bài viết: Những câu nói chào buổi sáng sẽ được yêu thích ngay lập tức khi đăng trên Khoảnh Khắc. Những câu nói chào buổi sáng đầy ý nghĩa.
Đề xuất bài viết: Thảo luận ngắn gọn về thuật toán đệ quy Python
qq735679552
Hồ sơ

Tôi là một lập trình viên xuất sắc, rất giỏi!

Nhận phiếu giảm giá taxi Didi miễn phí
Phiếu giảm giá taxi Didi
Các bài viết phổ biến trên toàn bộ trang web
Chứng chỉ ICP Bắc Kinh số 000000
Hợp tác quảng cáo: 1813099741@qq.com 6ren.com
Xem sitemap của VNExpress