Berikut ini tentu saja semua tidak terlalu tepat. Ambillah dengan sebutir garam ketika Anda membacanya :)
Nah, tiga hal yang Anda rujuk adalah durasi penyimpanan otomatis, statis, dan dinamis , yang berkaitan dengan berapa lama objek hidup dan kapan mereka mulai hidup.
Durasi penyimpanan otomatis
Anda menggunakan durasi penyimpanan otomatis untuk data yang berumur pendek dan kecil , yang hanya diperlukan secara lokal dalam beberapa blok:
if(some condition) {
int a[3]; // array a has automatic storage duration
fill_it(a);
print_it(a);
}
Seumur hidup berakhir segera setelah kita keluar dari blok, dan itu dimulai segera setelah objek didefinisikan. Mereka adalah jenis paling lama durasi penyimpanan, dan jauh lebih cepat daripada dalam durasi penyimpanan dinamis tertentu.
Durasi penyimpanan statis
Anda menggunakan durasi penyimpanan statis untuk variabel gratis, yang dapat diakses oleh kode apa saja setiap saat, jika ruang lingkup mereka memungkinkan penggunaan tersebut (ruang lingkup namespace), dan untuk variabel lokal yang perlu memperpanjang masa hidup mereka di keluar dari ruang lingkup mereka (cakupan lokal), dan untuk variabel anggota yang perlu dibagikan oleh semua objek dari kelas mereka (kelas lingkup). Masa hidup mereka tergantung pada ruang lingkup mereka. Mereka dapat memiliki ruang nama dan ruang lingkup lokal dan ruang kelas . Apa yang benar tentang mereka berdua adalah, begitu kehidupan mereka dimulai, kehidupan berakhir pada akhir program . Berikut ini dua contoh:
// static storage duration. in global namespace scope
string globalA;
int main() {
foo();
foo();
}
void foo() {
// static storage duration. in local scope
static string localA;
localA += "ab"
cout << localA;
}
Program mencetak ababab, karena localAtidak dihancurkan saat keluar dari bloknya. Anda dapat mengatakan bahwa objek yang memiliki cakupan lokal mulai seumur hidup ketika kontrol mencapai definisi mereka . Sebab localA, itu terjadi ketika fungsi tubuh dimasukkan. Untuk objek dalam lingkup namespace, seumur hidup dimulai saat startup program . Hal yang sama berlaku untuk objek statis dari ruang lingkup kelas:
class A {
static string classScopeA;
};
string A::classScopeA;
A a, b; &a.classScopeA == &b.classScopeA == &A::classScopeA;
Seperti yang Anda lihat, classScopeAtidak terikat pada objek tertentu dari kelasnya, tetapi pada kelas itu sendiri. Alamat ketiga nama di atas adalah sama, dan semuanya menunjukkan objek yang sama. Ada aturan khusus tentang kapan dan bagaimana objek statis diinisialisasi, tetapi jangan khawatir tentang itu sekarang. Itu dimaksud dengan istilah kegagalan inisialisasi statis .
Durasi penyimpanan dinamis
Durasi penyimpanan terakhir adalah dinamis. Anda menggunakannya jika Anda ingin memiliki objek hidup di pulau lain, dan Anda ingin meletakkan pointer di sekitar referensi itu. Anda juga menggunakannya jika objek Anda besar , dan jika Anda ingin membuat array ukuran yang hanya diketahui saat runtime . Karena fleksibilitas ini, objek yang memiliki durasi penyimpanan dinamis rumit dan lambat untuk dikelola. Objek yang memiliki durasi dinamis itu mulai seumur hidup ketika doa operator baru yang sesuai terjadi:
int main() {
// the object that s points to has dynamic storage
// duration
string *s = new string;
// pass a pointer pointing to the object around.
// the object itself isn't touched
foo(s);
delete s;
}
void foo(string *s) {
cout << s->size();
}
Masa pakainya berakhir hanya ketika Anda memanggil hapus untuk mereka. Jika Anda lupa itu, benda-benda itu tidak pernah berakhir seumur hidup. Dan objek kelas yang mendefinisikan konstruktor yang dinyatakan pengguna tidak akan memiliki destruktor yang dipanggil. Objek yang memiliki durasi penyimpanan dinamis memerlukan penanganan manual seumur hidup dan sumber daya memori terkait. Perpustakaan ada untuk memudahkan penggunaannya. Pengumpulan sampah eksplisit untuk objek tertentu dapat dibuat dengan menggunakan pointer pintar:
int main() {
shared_ptr<string> s(new string);
foo(s);
}
void foo(shared_ptr<string> s) {
cout << s->size();
}
Anda tidak perlu peduli dengan panggilan delete: ptr yang dibagikan melakukannya untuk Anda, jika pointer terakhir yang mereferensikan objek keluar dari cakupan. Ptr bersama itu sendiri memiliki durasi penyimpanan otomatis. Jadi masa hidupnya dikelola secara otomatis, memungkinkannya untuk memeriksa apakah ia harus menghapus objek dinamis yang diarahkan ke destruktornya. Untuk referensi shared_ptr, lihat mendongkrak dokumen: http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/shared_ptr.htm