Bộ nhớ của một biến cục bộ có thể được truy cập bên ngoài phạm vi của nó không?

Tôi có mã sau đây.

#include <iostream>

int * foo()
{
    int a = 5;
    return &a;
}

int main()
{
    int* p = foo();
    std::cout << *p;
    *p = 8;
    std::cout << *p;
}

Và mã chỉ đang chạy mà không có ngoại lệ thời gian chạy!

Đầu ra là 58

Làm thế nào nó có thể được? Không phải bộ nhớ của một biến cục bộ không thể truy cập bên ngoài chức năng của nó?

Làm thế nào nó có thể được? Không phải bộ nhớ của một biến cục bộ không thể truy cập bên ngoài chức năng của nó?

Bạn thuê một phòng khách sạn. Bạn đặt một cuốn sách vào ngăn kéo trên cùng của bàn cạnh giường ngủ và đi ngủ. Bạn kiểm tra vào sáng hôm sau, nhưng "quên" để trả lại chìa khóa của bạn. Bạn ăn cắp chìa khóa!

Một tuần sau, bạn trở về khách sạn, không nhận phòng, lẻn vào phòng cũ bằng chìa khóa bị đánh cắp và tìm trong ngăn kéo. Cuốn sách của bạn vẫn còn đó. Kinh ngạc!

Làm thế nào mà có thể được? Không phải nội dung của ngăn kéo phòng khách sạn không thể truy cập nếu bạn chưa thuê phòng?

Chà, rõ ràng kịch bản đó có thể xảy ra trong thế giới thực không có vấn đề gì. Không có thế lực bí ẩn nào khiến cuốn sách của bạn biến mất khi bạn không còn được phép ở trong phòng. Cũng không có một thế lực bí ẩn nào ngăn bạn vào một căn phòng có chìa khóa bị đánh cắp.

Quản lý khách sạn không bắt buộc phải xóa sách của bạn. Bạn đã không ký hợp đồng với họ nói rằng nếu bạn để lại đồ đạc, họ sẽ hủy nó cho bạn. Nếu bạn vào lại phòng của bạn một cách bất hợp pháp với chìa khóa bị đánh cắp để lấy lại, nhân viên an ninh khách sạn không bắt buộc bạn phải lẻn vào. Bạn đã không ký hợp đồng với họ rằng "nếu tôi cố gắng lẻn vào phòng sau, bạn được yêu cầu ngăn chặn tôi. " Thay vào đó, bạn đã ký hợp đồng với họ với nội dung "Tôi hứa sẽ không lẻn vào phòng tôi sau", một hợp đồng mà bạn đã phá vỡ .

Trong tình huống này bất cứ điều gì cũng có thể xảy ra . Cuốn sách có thể ở đó - bạn đã gặp may mắn. Cuốn sách của người khác có thể ở đó và cuốn sách của bạn có thể ở trong lò của khách sạn. Ai đó có thể ở đó ngay khi bạn bước vào, xé sách của bạn thành từng mảnh. Khách sạn có thể đã loại bỏ bàn và đặt hoàn toàn và thay thế nó bằng một tủ quần áo. Toàn bộ khách sạn có thể sắp bị phá hủy và thay thế bằng một sân bóng đá, và bạn sẽ chết trong một vụ nổ trong khi bạn đang lén lút xung quanh.

Bạn không biết điều gì sẽ xảy ra; Khi bạn rời khỏi khách sạn và lấy trộm chìa khóa để sử dụng bất hợp pháp sau đó, bạn đã từ bỏ quyền sống trong một thế giới an toàn, có thể dự đoán được vì bạn đã chọn phá vỡ các quy tắc của hệ thống.

C ++ không phải là một ngôn ngữ an toàn . Nó sẽ vui vẻ cho phép bạn phá vỡ các quy tắc của hệ thống. Nếu bạn cố làm điều gì đó bất hợp pháp và dại dột như quay trở lại phòng mà bạn không được phép ở trong và lục lọi bàn làm việc thậm chí không còn ở đó nữa, C ++ sẽ không ngăn bạn. Các ngôn ngữ an toàn hơn C ++ giải quyết vấn đề này bằng cách hạn chế sức mạnh của bạn - bằng cách kiểm soát các phím chặt chẽ hơn nhiều, chẳng hạn.

CẬP NHẬT

Chúa ơi, câu trả lời này đang được chú ý rất nhiều. (Tôi không chắc tại sao - Tôi coi đó chỉ là một sự tương tự nhỏ "vui vẻ", nhưng bất cứ điều gì.)

Tôi nghĩ rằng nó có thể là nguyên bản để cập nhật điều này một chút với một vài suy nghĩ kỹ thuật.

Trình biên dịch đang kinh doanh trong việc tạo mã quản lý việc lưu trữ dữ liệu được thao tác bởi chương trình đó. Có rất nhiều cách khác nhau để tạo mã để quản lý bộ nhớ, nhưng theo thời gian, hai kỹ thuật cơ bản đã trở nên cố thủ.

Đầu tiên là có một vùng lưu trữ "tồn tại lâu" trong đó "tuổi thọ" của mỗi byte trong bộ lưu trữ - nghĩa là khoảng thời gian khi nó được liên kết hợp lệ với một số biến chương trình - không thể dự đoán dễ dàng trước của thời gian Trình biên dịch tạo các cuộc gọi vào một "trình quản lý heap" biết cách phân bổ động lưu trữ khi cần thiết và lấy lại khi không cần thiết nữa.

Phương pháp thứ hai là có một vùng lưu trữ thời gian ngắn có thời gian ngắn, trong đó tuổi thọ của mỗi byte được biết đến. Ở đây, các kiếp sống theo mô hình lồng nhau của hoàng tử. Thời gian tồn tại lâu nhất của các biến có thời gian tồn tại ngắn này sẽ được phân bổ trước bất kỳ biến có thời gian tồn tại ngắn nào khác và sẽ được giải phóng sau cùng. Các biến có thời gian tồn tại ngắn hơn sẽ được phân bổ sau các biến có thời gian tồn tại lâu nhất và sẽ được giải phóng trước chúng. Thời gian tồn tại của các biến có thời gian tồn tại ngắn hơn này là lồng nhau lồng nhau trong vòng đời của các biến có thời gian tồn tại lâu hơn.

Các biến cục bộ theo mô hình sau; khi một phương thức được nhập vào, các biến cục bộ của nó trở nên sống động. Khi phương thức đó gọi một phương thức khác, các biến cục bộ của phương thức mới trở nên sống động. Họ sẽ chết trước khi các biến cục bộ của phương thức đầu tiên bị chết. Thứ tự tương đối của sự khởi đầu và kết thúc của thời gian sống của kho lưu trữ liên quan đến các biến cục bộ có thể được thực hiện trước thời hạn.

Vì lý do này, các biến cục bộ thường được tạo dưới dạng lưu trữ trên cấu trúc dữ liệu "ngăn xếp", bởi vì một ngăn xếp có thuộc tính mà điều đầu tiên được đẩy vào nó sẽ là điều cuối cùng xuất hiện.

Giống như khách sạn quyết định chỉ thuê phòng theo tuần tự và bạn không thể trả phòng cho đến khi mọi người có số phòng cao hơn bạn đã trả phòng.

Vì vậy, hãy nghĩ về ngăn xếp. Trong nhiều hệ điều hành, bạn nhận được một ngăn xếp trên mỗi luồng và ngăn xếp được phân bổ theo một kích thước cố định nhất định. Khi bạn gọi một phương thức, công cụ sẽ được đẩy lên ngăn xếp. Nếu sau đó bạn chuyển một con trỏ tới ngăn xếp ra khỏi phương thức của bạn, như áp phích ban đầu thực hiện ở đây, thì đó chỉ là một con trỏ ở giữa một khối bộ nhớ triệu byte hoàn toàn hợp lệ. Tương tự như vậy, bạn trả phòng khách sạn; Khi bạn làm, bạn chỉ cần kiểm tra ra khỏi phòng chiếm số lượng cao nhất. Nếu không có ai khác đăng ký sau bạn và bạn quay trở lại phòng của bạn một cách bất hợp pháp, tất cả đồ đạc của bạn được đảm bảo vẫn còn ở đó trong khách sạn đặc biệt này .

Chúng tôi sử dụng ngăn xếp cho các cửa hàng tạm thời bởi vì chúng thực sự rẻ và dễ dàng. Không cần phải thực hiện C ++ để sử dụng ngăn xếp để lưu trữ cục bộ; nó có thể sử dụng đống. Nó không, bởi vì điều đó sẽ làm cho chương trình chậm hơn.

Việc triển khai C ++ là không bắt buộc để lại rác mà bạn để lại trên ngăn xếp không bị ảnh hưởng để bạn có thể quay lại để lấy nó bất hợp pháp sau này; việc trình biên dịch tạo mã trở về 0 mọi thứ trong "phòng" mà bạn vừa bỏ trống là hoàn toàn hợp pháp. Nó không phải bởi vì một lần nữa, đó sẽ là đắt tiền.

Việc triển khai C ++ là không bắt buộc để đảm bảo rằng khi ngăn xếp co lại một cách hợp lý, các địa chỉ được sử dụng là hợp lệ vẫn được ánh xạ vào bộ nhớ. Việc triển khai được phép nói với hệ điều hành "chúng ta đã hoàn thành việc sử dụng trang stack này ngay bây giờ. Cho đến khi tôi nói khác, hãy đưa ra một ngoại lệ phá hủy quy trình nếu có ai chạm vào trang stack hợp lệ trước đó". Một lần nữa, việc triển khai không thực sự làm điều đó bởi vì nó chậm và không cần thiết.

Thay vào đó, việc triển khai cho phép bạn phạm sai lầm và thoát khỏi nó. Hầu hết thời gian. Cho đến một ngày một cái gì đó thực sự khủng khiếp đi sai và quá trình bùng nổ.

Đây là vấn đề. Có rất nhiều quy tắc và rất dễ dàng để phá vỡ chúng một cách vô tình. Tôi chắc chắn có nhiều lần. Và tệ hơn, vấn đề thường chỉ xuất hiện khi bộ nhớ được phát hiện là hỏng hàng tỷ nano giây sau khi tham nhũng xảy ra, khi rất khó để tìm ra ai đã làm nó rối tung lên.

Nhiều ngôn ngữ an toàn bộ nhớ giải quyết vấn đề này bằng cách hạn chế sức mạnh của bạn. Trong C # "bình thường" đơn giản là không có cách nào để lấy địa chỉ của một địa phương và trả lại hoặc lưu trữ nó sau này. Bạn có thể lấy địa chỉ của một địa phương, nhưng ngôn ngữ được thiết kế khéo léo để không thể sử dụng nó sau khi vòng đời của địa phương kết thúc. Để lấy địa chỉ của một địa phương và chuyển lại, bạn phải đặt trình biên dịch ở chế độ "không an toàn" đặc biệt và đặt từ "không an toàn" trong chương trình của bạn, để chú ý đến thực tế rằng bạn có thể đang làm một cái gì đó nguy hiểm có thể phá vỡ các quy tắc.

Để đọc thêm:

• Điều gì nếu C # đã cho phép trả lại tài liệu tham khảo? Thật trùng hợp, đó là chủ đề của bài viết blog ngày hôm nay:

  https://ericlippert.com/2011/06/23/ref-returns-and-ref-locals/

• Tại sao chúng ta sử dụng ngăn xếp để quản lý bộ nhớ? Các loại giá trị trong C # luôn được lưu trữ trên ngăn xếp? Bộ nhớ ảo hoạt động như thế nào? Và nhiều chủ đề khác trong cách trình quản lý bộ nhớ C # hoạt động. Nhiều bài viết trong số này cũng là nguyên nhân cho các lập trình viên C ++:

  https://ericlippert.com/tag/memory-man Management /

Những gì bạn đang làm ở đây chỉ đơn giản là đọc và ghi vào bộ nhớ từng là địa chỉ của a. Bây giờ bạn đang ở ngoài foo, nó chỉ là một con trỏ đến một vùng nhớ ngẫu nhiên. Nó chỉ xảy ra rằng trong ví dụ của bạn, vùng nhớ đó tồn tại và không có gì khác đang sử dụng nó vào lúc này. Bạn không phá vỡ bất cứ điều gì bằng cách tiếp tục sử dụng nó và chưa có gì khác ghi đè lên nó. Do đó, 5vẫn còn đó. Trong một chương trình thực tế, bộ nhớ đó sẽ được sử dụng lại gần như ngay lập tức và bạn sẽ phá vỡ thứ gì đó bằng cách thực hiện điều này (mặc dù các triệu chứng có thể không xuất hiện cho đến sau này!)

Khi bạn trở về foo, bạn nói với HĐH rằng bạn không còn sử dụng bộ nhớ đó nữa và nó có thể được gán lại cho thứ khác. Nếu bạn may mắn và nó không bao giờ được chỉ định lại, và HĐH không bắt bạn sử dụng lại, thì bạn sẽ thoát khỏi sự dối trá. Có thể mặc dù bạn sẽ kết thúc bằng văn bản về bất cứ điều gì khác kết thúc với địa chỉ đó.

Bây giờ nếu bạn đang tự hỏi tại sao trình biên dịch không phàn nàn, có lẽ vì foođã bị loại bỏ bởi tối ưu hóa. Nó thường sẽ cảnh báo bạn về loại điều này. C giả định rằng bạn biết những gì bạn đang làm và về mặt kỹ thuật bạn không vi phạm phạm vi ở đây (không có tham chiếu nào abên ngoài foo), chỉ có các quy tắc truy cập bộ nhớ, chỉ kích hoạt cảnh báo thay vì lỗi.

Nói tóm lại: điều này thường không hoạt động, nhưng đôi khi sẽ tình cờ.

Bởi vì không gian lưu trữ chưa được dậm chân. Đừng tin vào hành vi đó.

Một bổ sung nhỏ cho tất cả các câu trả lời:

nếu bạn làm một cái gì đó như thế:

#include<stdio.h>
#include <stdlib.h>
int * foo(){
    int a = 5;
    return &a;
}
void boo(){
    int a = 7;

}
int main(){
    int * p = foo();
    boo();
    printf("%d\n",*p);
}

đầu ra có thể sẽ là: 7

Đó là bởi vì sau khi trở về từ foo (), ngăn xếp được giải phóng và sau đó được sử dụng lại bởi boo (). Nếu bạn lắp ráp lại tệp thực thi, bạn sẽ thấy nó rõ ràng.

Trong C ++, bạn có thể truy cập bất kỳ địa chỉ nào, nhưng điều đó không có nghĩa là bạn nên . Địa chỉ bạn đang truy cập không còn hợp lệ. Nó hoạt động vì không có gì khác làm xáo trộn bộ nhớ sau khi foo trở lại, nhưng nó có thể bị sập trong nhiều trường hợp. Hãy thử phân tích chương trình của bạn với Valgrind hoặc thậm chí chỉ biên dịch chương trình được tối ưu hóa và xem ...

Bạn không bao giờ ném ngoại lệ C ++ bằng cách truy cập bộ nhớ không hợp lệ. Bạn chỉ đưa ra một ví dụ về ý tưởng chung về việc tham chiếu một vị trí bộ nhớ tùy ý. Tôi có thể làm như thế này:

unsigned int q = 123456;

*(double*)(q) = 1.2;

Ở đây tôi chỉ đơn giản coi 123456 là địa chỉ của một đôi và viết cho nó. Bất kỳ số lượng điều có thể xảy ra:

1. qtrong thực tế có thể là một địa chỉ hợp lệ của một đôi, ví dụ double p; q = &p;.
2. q có thể chỉ ra một nơi nào đó bên trong bộ nhớ được phân bổ và tôi chỉ ghi đè lên 8 byte trong đó.
3. q các điểm bên ngoài bộ nhớ được phân bổ và trình quản lý bộ nhớ của hệ điều hành sẽ gửi tín hiệu lỗi phân đoạn đến chương trình của tôi, khiến cho bộ thực thi chấm dứt nó.
4. Bạn trúng xổ số.

Cách bạn thiết lập nó hợp lý hơn một chút là địa chỉ được trả về chỉ vào một vùng bộ nhớ hợp lệ, vì nó có thể sẽ nằm sâu hơn một chút trong ngăn xếp, nhưng nó vẫn là một vị trí không hợp lệ mà bạn không thể truy cập trong một thời trang quyết định.

Không ai sẽ tự động kiểm tra tính hợp lệ ngữ nghĩa của các địa chỉ bộ nhớ như thế đối với bạn trong quá trình thực thi chương trình bình thường. Tuy nhiên, một trình gỡ lỗi bộ nhớ như valgrindsẽ vui vẻ làm điều này, vì vậy bạn nên chạy chương trình của mình thông qua nó và chứng kiến ​​các lỗi.

Bạn đã biên dịch chương trình của mình với trình tối ưu hóa được kích hoạt chưa? Các foo()chức năng khá đơn giản và có thể đã bị inlined hoặc thay thế trong những mã kết quả.

Nhưng tôi đồng ý với Mark B rằng hành vi kết quả là không xác định.

Vấn đề của bạn không có gì để làm với phạm vi . Trong mã bạn hiển thị, hàm mainkhông nhìn thấy tên trong hàm foo, vì vậy bạn không thể truy cập atrực tiếp vào foo với tên này bên ngoài foo.

Vấn đề bạn gặp phải là tại sao chương trình không báo hiệu lỗi khi tham chiếu bộ nhớ bất hợp pháp. Điều này là do các tiêu chuẩn C ++ không chỉ định ranh giới rất rõ ràng giữa bộ nhớ bất hợp pháp và bộ nhớ hợp pháp. Tham chiếu một cái gì đó trong ngăn xếp bật ra đôi khi gây ra lỗi và đôi khi không. Nó phụ thuộc. Đừng tin vào hành vi này. Giả sử nó sẽ luôn dẫn đến lỗi khi bạn lập trình, nhưng giả sử nó sẽ không bao giờ báo hiệu lỗi khi bạn gỡ lỗi.

Bạn chỉ trả về một địa chỉ bộ nhớ, nó được phép nhưng có thể là một lỗi.

Có nếu bạn cố gắng xác nhận lại rằng địa chỉ bộ nhớ bạn sẽ có hành vi không xác định.

int * ref () {

 int tmp = 100;
 return &tmp;
}

int main () {

 int * a = ref();
 //Up until this point there is defined results
 //You can even print the address returned
 // but yes probably a bug

 cout << *a << endl;//Undefined results
}

Đó là hành vi không xác định cổ điển đã được thảo luận ở đây không phải hai ngày trước - tìm kiếm trên trang web một chút. Tóm lại, bạn đã may mắn, nhưng bất cứ điều gì cũng có thể xảy ra và mã của bạn đang truy cập bộ nhớ không hợp lệ.

Hành vi này không được xác định, như Alex chỉ ra - trên thực tế, hầu hết các trình biên dịch sẽ cảnh báo không làm điều này, bởi vì đó là một cách dễ dàng để gặp sự cố.

Để biết ví dụ về loại hành vi ma quái mà bạn có thể gặp phải, hãy thử mẫu này:

int *a()
{
   int x = 5;
   return &x;
}

void b( int *c )
{
   int y = 29;
   *c = 123;
   cout << "y=" << y << endl;
}

int main()
{
   b( a() );
   return 0;
}

Điều này in ra "y = 123", nhưng kết quả của bạn có thể thay đổi (thực sự!). Con trỏ của bạn đang ghi đè các biến cục bộ khác, không liên quan.

Hãy chú ý đến tất cả các cảnh báo. Không chỉ giải quyết lỗi.
GCC hiển thị Cảnh báo này

cảnh báo: địa chỉ của biến cục bộ 'a' được trả về

Đây là sức mạnh của C ++. Bạn nên quan tâm đến trí nhớ. Với -Werrorcờ, cảnh báo này có lỗi và bây giờ bạn phải gỡ lỗi.

Nó hoạt động vì ngăn xếp chưa được thay đổi (chưa) kể từ khi được đặt ở đó. Gọi một vài chức năng khác (cũng đang gọi các chức năng khác) trước khi truy cập alại và bạn có thể sẽ không còn may mắn nữa ... ;-)

Bạn thực sự viện dẫn hành vi không xác định.

Trả lại địa chỉ của một công trình tạm thời, nhưng vì tạm thời bị phá hủy ở cuối chức năng, kết quả truy cập chúng sẽ không được xác định.

Vì vậy, bạn đã không sửa đổi amà thay vào đó là vị trí bộ nhớ a. Sự khác biệt này rất giống với sự khác biệt giữa sự cố và không bị rơi.

Trong các triển khai trình biên dịch điển hình, bạn có thể nghĩ mã là "in ra giá trị của khối bộ nhớ với địa chỉ đã từng bị chiếm bởi". Ngoài ra, nếu bạn thêm một lời gọi hàm mới vào một hàm chứa một cục bộ intthì rất có thể giá trị của a(hoặc địa chỉ bộ nhớ ađược sử dụng để trỏ đến) thay đổi. Điều này xảy ra vì ngăn xếp sẽ được ghi đè bằng một khung mới chứa dữ liệu khác nhau.

Tuy nhiên, đây là hành vi không xác định và bạn không nên dựa vào nó để làm việc!

Nó có thể, bởi vì alà một biến được phân bổ tạm thời cho vòng đời của phạm vi ( foohàm) của nó. Sau khi bạn trở về từ foobộ nhớ là miễn phí và có thể được ghi đè.

Những gì bạn đang làm được mô tả là hành vi không xác định . Kết quả không thể dự đoán.

Những thứ có đầu ra giao diện điều khiển chính xác (?) Có thể thay đổi đáng kể nếu bạn sử dụng :: printf nhưng không phải cout. Bạn có thể chơi xung quanh với trình gỡ lỗi trong mã bên dưới (được thử nghiệm trên x86, 32-bit, MSVisual Studio):

char* foo() 
{
  char buf[10];
  ::strcpy(buf, "TEST”);
  return buf;
}

int main() 
{
  char* s = foo();    //place breakpoint & check 's' varialbe here
  ::printf("%s\n", s); 
}

Sau khi trở về từ một hàm, tất cả các mã định danh bị hủy thay vì giữ các giá trị trong một vị trí bộ nhớ và chúng ta không thể định vị các giá trị mà không có mã định danh. Nhưng vị trí đó vẫn chứa giá trị được lưu bởi hàm trước đó.

Vì vậy, ở đây hàm foo()đang trả về địa chỉ của avà abị hủy sau khi trả lại địa chỉ của nó. Và bạn có thể truy cập giá trị sửa đổi thông qua địa chỉ trả lại.

Hãy để tôi lấy một ví dụ thực tế:

Giả sử một người đàn ông giấu tiền tại một địa điểm và cho bạn biết địa điểm. Sau một thời gian, người đàn ông đã nói với bạn vị trí tiền chết. Nhưng bạn vẫn có quyền truy cập vào số tiền ẩn đó.

Đó là cách 'bẩn' sử dụng địa chỉ bộ nhớ. Khi bạn trả về một địa chỉ (con trỏ), bạn không biết liệu nó có thuộc phạm vi cục bộ của hàm không. Nó chỉ là một địa chỉ. Bây giờ bạn đã gọi hàm 'foo', địa chỉ đó (vị trí bộ nhớ) của 'a' đã được phân bổ ở đó trong bộ nhớ (quy trình) ít nhất là an toàn cho ứng dụng của bạn (quá trình). Sau khi hàm 'foo' được trả về, địa chỉ của 'a' có thể được coi là 'bẩn' nhưng nó ở đó, không được dọn dẹp, cũng không bị làm phiền / sửa đổi bởi các biểu thức trong phần khác của chương trình (ít nhất là trong trường hợp cụ thể này). Trình biên dịch AC / C ++ không ngăn bạn truy cập 'bẩn' như vậy (có thể cảnh báo bạn, nếu bạn quan tâm).

Mã của bạn rất rủi ro. Bạn đang tạo một biến cục bộ (wich được coi là bị hủy sau khi hàm kết thúc) và bạn trả về địa chỉ bộ nhớ của biến đó sau khi nó bị hủy.

Điều đó có nghĩa là địa chỉ bộ nhớ có thể hợp lệ hoặc không và mã của bạn sẽ dễ bị ảnh hưởng bởi các sự cố địa chỉ bộ nhớ có thể xảy ra (ví dụ như lỗi phân đoạn).

Điều này có nghĩa là bạn đang làm một điều rất tồi tệ, vì bạn đang truyền một địa chỉ bộ nhớ cho một con trỏ mà không đáng tin chút nào.

Thay vào đó, hãy xem xét ví dụ này và kiểm tra nó:

int * foo()
{
   int *x = new int;
   *x = 5;
   return x;
}

int main()
{
    int* p = foo();
    std::cout << *p << "\n"; //better to put a new-line in the output, IMO
    *p = 8;
    std::cout << *p;
    delete p;
    return 0;
}

Không giống như ví dụ của bạn, với ví dụ này, bạn là:

• cấp phát bộ nhớ cho int vào một hàm cục bộ
• địa chỉ bộ nhớ đó vẫn còn hiệu lực khi hết hạn chức năng, (nó không bị xóa bởi bất kỳ ai)
• địa chỉ bộ nhớ là đáng tin cậy (khối bộ nhớ đó không được coi là miễn phí, vì vậy nó sẽ không bị ghi đè cho đến khi bị xóa)
• địa chỉ bộ nhớ sẽ bị xóa khi không sử dụng. (xem phần xóa ở cuối chương trình)