[Tự học C++] Giới thiệu về phạm vi(scope) của biến hoặc hàm cục bộ

1. Biến cục bộ

Các tham số của hàm, cũng như các biến được định nghĩa bên trong thân hàm, được gọi là các biến cục bộ (trái ngược với các biến toàn cục, mà chúng ta sẽ thảo luận trong chương tiếp theo).

int add(int x, int y) // function parameters x and y are local variables
{
    int z{ x + y }; // z is a local variable too
 
    return z;
}

Trong bài học này, chúng ta sẽ xem xét một số đặc điểm của các biến cục bộ một cách chi tiết hơn.

2. Vòng đời của biến cục bộ

Trong bài 1.3 – Giới thiệu về các biến, chúng ta đã thảo luận về cách định nghĩa biến như int x; làm cho biến được khởi tạo khi câu lệnh này được thực thi. Các tham số của hàm được tạo và khởi tạo khi hàm được gọi và các biến trong thân hàm được tạo và khởi tạo tại thời điểm định nghĩa.

Ví dụ:

int add(int x, int y) // x and y created and initialized here
{ 
    int z{ x + y }; // z created and initialized here
 
    return z;
}

Câu hỏi tiếp theo là, khi nào thì một biến cục bộ bị hủy? Các biến cục bộ bị hủy theo thứ tự ngược lại của việc khởi tạo nó khi tới dấu ngoặc nhọn cuối cùng của hàm, nơi mà nó được định nghĩa.

int add(int x, int y)
{ 
    int z{ x + y };
 
    return z;
} // z, y, and x destroyed here

Giống như thời gian sống của một con người, chính là thời gian giữa lúc sinh và lúc chết của họ, thời gian sống của đối tượng được định nghĩa là thời gian giữa việc tạo ra và hủy nó. Lưu ý rằng việc tạo và hủy biến xảy ra khi chương trình đang chạy (được gọi là thời gian chạy), không phải lúc biên dịch. Do đó, Vòng đời là một thuộc tính trong thời gian chạy chương trình.

Các quy tắc dựa trên xung quanh việc tạo, khởi tạo và hủy đối tượng. Nghĩa là, các đối tượng phải được tạo và khởi tạo trước thời điểm nó định nghĩa và bị hủy ở phần cuối của dấu ngoặc nhọn.

Trong thực tế, đặc tả của C ++ cung cấp cho trình biên dịch rất nhiều tính linh hoạt để xác định khi nào các biến cục bộ được tạo và hủy. Các đối tượng có thể được tạo ra sớm hơn hoặc bị hủy ngay sau đó cho mục đích tối ưu hóa. Thông thường, các biến cục bộ được tạo khi hàm được gọi và bị hủy theo thứ tự ngược lại khi tạo hàm. Chúng ta sẽ thảo luận chi tiết hơn về điều này trong các bài học trong tiếp theo, khi chúng ta nói về ngăn xếp các cuộc gọi.

Ở đây, có một chương trình phức tạp hơi phức tạp giúp thể hiện thời gian tồn tại của một biến có tên x:

#include <iostream>
 
void doSomething()
{
    std::cout << "Hello!\n";
}
 
int main()
{
    int x{ 0 }; // x's lifetime begins here
 
    doSomething(); // x is still alive during this function call
 
    return 0;
} // x's lifetime ends here

Trong chương trình trên, vòng đời của x chạy từ điểm định nghĩa đến hết hàm main. Điều này bao gồm thời gian trong quá trình thực thi hàm doSomething.

3. Phạm vi cục bộ

Một phạm vi chính là một vùng đươc xác định mà nơi đó các biến, hàm, đối tượng.. có thể được truy cập trong code mà không phát sinh lỗi. Khi một định danh(Tên biến, tên đối tượng or hàm…) có thể được truy cập, chúng ta nói nó nằm trong phạm vi. Khi một định danh không thể được truy cập, chúng ta nói nó nằm ngoài phạm vi. Phạm vi là một thuộc tính thời gian khi biên dịch và cố gắng sử dụng một định danh khi nó không nằm trong phạm vi sẽ dẫn đến một lỗi biên dịch.

Phạm vi của biến đổi cục bộ bắt đầu tại điểm định nghĩa biến và dừng ở cuối dấu ngoặc nhọn, nơi mà chúng được xác định (hoặc cho các tham số của hàm, ở cuối hàm). Điều này đảm bảo các biến không thể được sử dụng trước điểm định nghĩa (ngay cả khi trình biên dịch chọn để tạo chúng trước đó).

Ở đây, một chương trình thể hiện phạm vi của một biến có tên x:

#include <iostream>
 
// x is not in scope anywhere in this function
void doSomething()
{
    std::cout << "Hello!\n";
}
 
int main()
{
    // x can not be used here because it's not in scope yet
 
    int x{ 0 }; // x enters scope here and can now be used
 
    doSomething();
 
    return 0;
} // x goes out of scope here and can no longer be used

Trong chương trình trên, biến x có phạm vi tại điểm định nghĩa và đi ra khỏi phạm vi ở cuối hàm main. Lưu ý rằng biến x không nằm trong phạm vi bên trong của hàm doSomething. Thực tế là gọi hàm main doSomething không liên quan trong trường hợp này.

Lưu ý rằng các biến cục bộ có cùng định nghĩa về phạm vi và thời gian tồn tại. Đối với các biến cục bộ, phạm vi và thời gian tồn tại được liên kết – nghĩa là, thời gian sống của biến biến bắt đầu khi nó đi vào phạm vi và kết thúc khi nó vượt ra khỏi phạm vi.

4. Một ví dụ khác

Đây là một ví dụ phức tạp hơn một chút. Hãy nhớ rằng, vòng đời là một thuộc tính trong thời gian chạy và phạm vi là thuộc tính trong thời gian biên dịch.

#include <iostream>
 
int add(int x, int y) // x and y are created and enter scope here
{
    // x and y are visible/usable within this function only
    return x + y;
} // y and x go out of scope and are destroyed here
 
int main()
{
    int a{ 5 }; // a is created, initialized, and enters scope here
    int b{ 6 }; // b is created, initialized, and enters scope here
 
    // a and b are usable within this function only
    std::cout << add(a, b) << '\n'; // calls function add() with x=5 and y=6
 
    return 0;
} // b and a go out of scope and are destroyed here

Và chúng ta đã làm xong.

Lưu ý rằng nếu hàm add được gọi hai lần, tham số x và y sẽ được tạo và hủy hai lần – một lần cho mỗi cuộc gọi. Trong một chương trình có nhiều hàm và lệnh gọi hàm, các biến được tạo và hủy thường xuyên.

5. Tách biệt giữa các Hàm

Trong ví dụ trên, nó dễ dàng thấy rằng các biến a và b là các biến khác nhau từ x và y.

Bây giờ hãy xem xét chương trình tương tự sau đây:

#include <iostream>
 
int add(int x, int y) // add's x and y are created and enter scope here
{
    // add's x and y are visible/usable within this function only
    return x + y;
} // add's y and x go out of scope and are destroyed here
 
int main()
{
    int x{ 5 }; // main's x is created, initialized, and enters scope here
    int y{ 6 }; // main's y is created, initialized, and enters scope here
 
    // main's x and y are usable within this function only
    std::cout << add(x, y) << '\n'; // calls function add() with x=5 and y=6
 
    return 0;
} // main's y and x go out of scope and are destroyed here

Trong ví dụ này, tất cả những gì chúng ta đã thực hiện là thay đổi tên của các biến a và b bên trong hàm main thành x và y. Chương trình này biên dịch và chạy giống hệt nhau, mặc dù các hàm main và add cả hai đều có các biến có tên x và y. Tại sao điều này làm việc?

Đầu tiên, chúng ta cần nhận ra rằng mặc dù các hàm main và add cả hai đều có các biến có tên x và y, các biến này là khác biệt. X và y trong hàm main không liên quan gì đến x và y trong hàm add – chúng chỉ xảy ra để chia sẻ cùng tên.

Thứ hai, khi bên trong hàm main, các tên x và y được định nghĩa trong hàm main. Những biến đó chỉ có thể được nhìn thấy (và được sử dụng) bên trong hàm main. Tương tự, khi bên trong hàm add, tên x và y tham chiếu đến tham số hàm x và y, chỉ có thể nhìn thấy (và được sử dụng) bên trong add.

Nói tóm lại, cả add và main đều không biết rằng hàm kia có các biến cùng tên. Bởi vì các phạm vi không chồng chéo nhau, nên nó luôn luôn rõ ràng với trình biên dịch mà x và y đang được nhắc đến bất cứ lúc nào.

Chúng ta sẽ nói nhiều hơn về phạm vi cục bộ và các loại phạm vi khác, trong một chương tiếp theo.

6. Nơi định nghĩa biến cục bộ

Các biến cục bộ bên trong thân hàm nên được định nghĩa tại nơi gần với lần sử dụng đầu tiên của chúng là hợp lý nhất:

#include <iostream>
 
int main()
{
	std::cout << "Enter an integer: ";
	int x{}; // x defined here
	std::cin >> x; // and used here
 
	std::cout << "Enter another integer: ";
	int y{}; // y defined here
	std::cin >> y; // and used here
 
	int sum{ x + y }; // sum defined here
	std::cout << "The sum is: " << sum << '\n'; // and used here
 
	return 0;
}

Trong ví dụ trên, mỗi biến được định nghĩa ngay trước khi nó được sử dụng lần đầu tiên. Ở đó, bạn không cần phải nghiêm khắc về vấn đề này – nếu bạn thích hoán đổi các dòng 5 và 6, thì đó là điều tốt.