C'de hafızayı nasıl yönettiğinizi gerçekten izlemeniz gerektiğini hep duymuşumdur. Ve hala C öğrenmeye başlıyorum, ama şimdiye kadar, ilgili aktiviteleri yönetmek için herhangi bir hafıza yapmak zorunda kalmadım .. Her zaman değişkenleri serbest bırakmak ve her türlü çirkin şeyler yapmak zorunda olduğumu hayal ettim. Ancak durum böyle görünmüyor.
Birisi bana (kod örnekleriyle) ne zaman "bellek yönetimi" yapmanız gerektiğine dair bir örnek gösterebilir mi?
Yanıtlar:
Değişkenlerin hafızaya alınabileceği iki yer vardır. Bunun gibi bir değişken oluşturduğunuzda:
int a;
char c;
char d[16];
Değişkenler " yığın " içinde oluşturulur . Yığın değişkenleri, kapsam dışına çıktıklarında (yani, kod artık onlara ulaşamadığında) otomatik olarak serbest bırakılır. Bunların "otomatik" değişkenler olarak adlandırıldığını duyabilirsiniz, ancak bu modası geçmiştir.
Birçok başlangıç örneği yalnızca yığın değişkenlerini kullanır.
Yığın iyidir çünkü otomatiktir, ancak aynı zamanda iki dezavantajı vardır: (1) Derleyicinin değişkenlerin ne kadar büyük olduğunu önceden bilmesi gerekir ve (b) yığın alanı biraz sınırlıdır. Örneğin: Windows'ta, Microsoft bağlayıcı için varsayılan ayarlar altında, yığın 1 MB olarak ayarlanmıştır ve değişkenleriniz için tümü kullanılamaz.
Derleme zamanında dizinizin ne kadar büyük olduğunu bilmiyorsanız veya büyük bir diziye veya yapıya ihtiyacınız varsa, "B planına" ihtiyacınız vardır.
Plan B, " yığın " olarak adlandırılır . Genellikle İşletim Sisteminin izin verdiği büyüklükte değişkenler oluşturabilirsiniz, ancak bunu kendiniz yapmanız gerekir. Daha önceki gönderiler size bunu yapmanın bir yolunu gösterdi, ancak başka yollar da var:
int size;
// ...
// Set size to some value, based on information available at run-time. Then:
// ...
char *p = (char *)malloc(size);
(Yığındaki değişkenlerin doğrudan değil, işaretçiler aracılığıyla değiştirildiğini unutmayın)
Bir yığın değişkeni oluşturduğunuzda, sorun, derleyicinin onunla işiniz bittiğini söyleyememesi, bu nedenle otomatik yayınlamayı kaybedersiniz. İşte burada bahsettiğiniz "manuel serbest bırakma" devreye girer. Kodunuz artık değişkene ne zaman ihtiyaç duyulmayacağına karar vermekten ve onu serbest bırakmaktan sorumludur, böylece bellek başka amaçlar için alınabilir. Yukarıdaki durum için:
free(p);
Bu ikinci seçeneği "iğrenç iş" yapan şey, değişkene artık ne zaman ihtiyaç duyulmadığını bilmenin her zaman kolay olmamasıdır. İhtiyacınız olmadığında bir değişkeni serbest bırakmayı unutmak, programınızın ihtiyaç duyduğu bellek miktarından daha fazlasını tüketmesine neden olur. Bu duruma "sızıntı" denir. "Sızan" bellek, programınız sona erene ve işletim sistemi tüm kaynaklarını kurtarana kadar hiçbir şey için kullanılamaz. Aslında onunla işiniz bitmeden bir yığın değişkenini yanlışlıkla serbest bırakırsanız daha kötü sorunlar bile mümkündür .
C ve C ++ 'da, yukarıda gösterildiği gibi yığın değişkenlerinizi temizlemekten sorumlusunuz. Ancak, Java ve .NET gibi C # gibi farklı bir yaklaşım kullanan ve yığının kendi kendine temizlendiği diller ve ortamlar vardır. "Çöp toplama" olarak adlandırılan bu ikinci yöntem, geliştirici için çok daha kolaydır, ancak ek yük ve performansta bir ceza ödersiniz. Bu bir denge.
(Daha basit ama umarım daha seviyeli bir cevap vermek için birçok detayı gözden geçirdim)
malloc(), nedeni UB, (char *)malloc(size);bkz. Stackoverflow.com/questions/605845/…
İşte bir örnek. Bir dizeyi çoğaltan bir strdup () işleviniz olduğunu varsayalım:
char *strdup(char *src)
{
char * dest;
dest = malloc(strlen(src) + 1);
if (dest == NULL)
abort();
strcpy(dest, src);
return dest;
}
Ve buna şöyle diyorsun:
main()
{
char *s;
s = strdup("hello");
printf("%s\n", s);
s = strdup("world");
printf("%s\n", s);
}
Programın çalıştığını görebilirsiniz, ancak belleği boşaltmadan (malloc aracılığıyla) bellek ayırdınız. Strdup'ı ikinci kez çağırdığınızda, işaretçinizi ilk bellek bloğuna kaybettiniz.
Bu küçük bellek miktarı için önemli bir sorun değil, ancak durumu bir düşünün:
for (i = 0; i < 1000000000; ++i) /* billion times */
s = strdup("hello world"); /* 11 bytes */
Şu anda 11 gig bellek kullandınız (bellek yöneticinize bağlı olarak muhtemelen daha fazla) ve çökmediyseniz, işleminiz muhtemelen oldukça yavaş ilerliyor.
Düzeltmek için, malloc () ile elde edilen her şeyi kullanmayı bitirdikten sonra free () çağırmanız gerekir:
s = strdup("hello");
free(s); /* now not leaking memory! */
s = strdup("world");
...
Umarım bu örnek yardımcı olur!
Yığın yerine yığın üzerinde bellek kullanmak istediğinizde "bellek yönetimi" yapmanız gerekir. Çalışma zamanına kadar bir dizinin ne kadar büyük olacağını bilmiyorsanız, o zaman yığını kullanmanız gerekir. Örneğin, bir dizede bir şey saklamak isteyebilirsiniz, ancak program çalıştırılana kadar içeriğinin ne kadar büyük olacağını bilmiyorsunuz. Bu durumda şöyle bir şey yazarsınız:
char *string = malloc(stringlength); // stringlength is the number of bytes to allocate
// Do something with the string...
free(string); // Free the allocated memory
Bence C'deki işaretçinin rolünü göz önünde bulundurmak için soruyu yanıtlamanın en kısa yolu olduğunu düşünüyorum. İşaretçi, kendinizi ayağınızdan vurmanız için muazzam bir kapasite pahasına size büyük bir özgürlük veren hafif ama güçlü bir mekanizmadır.
C'de işaretçilerinizin sahip olduğunuz anıyı işaret etmesini sağlama sorumluluğu size aittir ve yalnızca sizindir. Etkili yazmayı zorlaştıran işaretçilerden vazgeçmediğiniz sürece, bu organize ve disiplinli bir yaklaşım gerektirir.
Tarihe gönderilen yanıtlar, otomatik (yığın) ve yığın değişken tahsislerine odaklanır. Yığın tahsisini kullanmak otomatik olarak yönetilen ve uygun bellek sağlar, ancak bazı durumlarda (büyük arabellekler, özyinelemeli algoritmalar) korkunç yığın taşması sorununa yol açabilir. Yığın üzerinde tam olarak ne kadar bellek ayırabileceğinizi bilmek, sisteme çok bağlıdır. Bazı katıştırılmış senaryolarda sınırınız birkaç düzine bayt olabilir, bazı masaüstü senaryolarında megabaytları güvenle kullanabilirsiniz.
Yığın tahsisi, dile daha az özgüdür. Temel olarak, siz onu iade etmeye ('ücretsiz') hazır olana kadar size belirli boyutta bir bellek bloğunun sahipliğini veren bir dizi kütüphane çağrısıdır. Kulağa basit geliyor, ancak anlatılmamış programcı kederiyle ilişkilendiriliyor. Problemler basittir (aynı belleği iki kez boşaltmak veya hiç [bellek sızıntıları], yeterli bellek ayırmamak [arabellek taşması], vb.), Ancak kaçınılması ve hata ayıklaması zordur. Uygulamada son derece disiplinli bir yaklaşım kesinlikle zorunludur, ancak elbette dil bunu zorunlu kılmaz.
Diğer gönderiler tarafından görmezden gelinen başka bir bellek ayırma türünden bahsetmek istiyorum. Değişkenleri herhangi bir işlevin dışında bildirerek statik olarak tahsis etmek mümkündür. Genel olarak bu tür bir tahsisin kötü bir şöhrete sahip olduğunu düşünüyorum çünkü küresel değişkenler tarafından kullanılıyor. Bununla birlikte, bu şekilde ayrılan belleği kullanmanın tek yolunun bir spagetti kodu karmaşasındaki disiplinsiz bir küresel değişken olduğunu söyleyen hiçbir şey yoktur. Statik ayırma yöntemi, yalnızca yığının bazı tuzaklarından ve otomatik ayırma yöntemlerinden kaçınmak için kullanılabilir. Bazı C programcıları, büyük ve sofistike C katıştırılmış ve oyun programlarının yığın ayırma kullanılmadan inşa edildiğini öğrenince şaşırırlar.
Burada hafızanın nasıl tahsis edilip boşaltılacağına dair bazı harika cevaplar var ve bence C'yi kullanmanın daha zor tarafı, kullandığınız tek hafızanın ayırdığınız hafıza olmasını sağlamaktır - eğer bu doğru şekilde yapılmazsa, sonlandırdığınız şey Bu sitenin kuzeni - bir arabellek taşması - ve başka bir uygulama tarafından kullanılan belleğin üzerine yazıyor ve çok öngörülemeyen sonuçlar veriyor olabilirsiniz.
Bir örnek:
int main() {
char* myString = (char*)malloc(5*sizeof(char));
myString = "abcd";
}
Bu noktada, myString için 5 bayt ayırdınız ve onu "abcd \ 0" ile doldurdunuz (dizeler bir null - \ 0 ile biter). Dize ayırmanız
myString = "abcde";
Programınıza ayırdığınız 5 bayta "abcde" atıyor olacaksınız ve sondaki boş karakter bunun sonuna konulacak - belleğin kullanımınız için ayrılmamış bir parçası olabilir ve ücretsiz, ancak aynı şekilde başka bir uygulama tarafından da kullanılıyor olabilir - Bu, bellek yönetiminin bir hatanın öngörülemeyen (ve bazen tekrarlanamayan) sonuçlarının olacağı kritik bir parçasıdır.
strcpy()yerine kullanmak için düzenledim =; Sanırım Chris BC'nin niyeti buydu.
Hatırlanması gereken bir şey , işaretçilerinizi her zaman NULL olarak başlatmaktır, çünkü başlatılmamış bir işaretçi, işaretçi hatalarının sessizce ilerlemesini sağlayabilecek sahte rasgele bir geçerli bellek adresi içerebilir. NULL ile başlatılacak bir göstericiyi zorlayarak, bu işaretçiyi başlatmadan kullanıp kullanmadığınızı her zaman yakalayabilirsiniz. Bunun nedeni, işletim sistemlerinin boş işaretçi kullanımını yakalamak için 0x00000000 sanal adresini genel koruma istisnalarına "bağlamaları".
Ayrıca, int [10000] gibi büyük bir dizi tanımlamanız gerektiğinde dinamik bellek ayırmayı kullanmak isteyebilirsiniz. Onu yığına koyamazsınız çünkü o zaman, hm ... bir yığın taşması yaşarsınız.
Bir başka iyi örnek, bir veri yapısının, örneğin bağlantılı liste veya ikili ağaç uygulaması olabilir. Buraya yapıştırmak için bir örnek kodum yok ama bunu kolayca google'da yapabilirsiniz.
(Yazıyorum çünkü şimdiye kadarki cevapların pek uygun olmadığını düşünüyorum.)
Hafıza yönetiminin bahsetmeye değer olmasının nedeni, karmaşık yapılar oluşturmanızı gerektiren bir probleminiz / çözümünüz olduğu zamandır. (Yığın üzerinde aynı anda çok fazla alan ayırırsanız programlarınız çökerse, bu bir hatadır.) Tipik olarak, öğrenmeniz gereken ilk veri yapısı bir çeşit listedir . İşte aklıma gelen tek bir bağlantılı bir tane:
typedef struct listelem { struct listelem *next; void *data;} listelem;
listelem * create(void * data)
{
listelem *p = calloc(1, sizeof(listelem));
if(p) p->data = data;
return p;
}
listelem * delete(listelem * p)
{
listelem next = p->next;
free(p);
return next;
}
void deleteall(listelem * p)
{
while(p) p = delete(p);
}
void foreach(listelem * p, void (*fun)(void *data) )
{
for( ; p != NULL; p = p->next) fun(p->data);
}
listelem * merge(listelem *p, listelem *q)
{
while(p != NULL && p->next != NULL) p = p->next;
if(p) {
p->next = q;
return p;
} else
return q;
}
Doğal olarak, birkaç başka işlev daha istersiniz, ancak temelde bu, bellek yönetimine ihtiyacınız olan şeydir. "Manuel" bellek yönetimi ile mümkün olan bir dizi numara olduğunu belirtmeliyim, örneğin,
İyi bir hata ayıklayıcı alın ... İyi şanslar!
Eklenecek bir olumsuzluk, işlev döndüğünde yığına işaretçilerin artık geçerli olmamasıdır, bu nedenle bir işlevden bir yığın değişkenine bir işaretçi döndüremezsiniz. Bu yaygın bir hatadır ve yalnızca yığın değişkenleriyle başa çıkamamanızın ana nedenlerinden biridir. İşlevinizin bir işaretçi döndürmesi gerekiyorsa, o zaman malloc ve bellek yönetimi ile uğraşmanız gerekir.
@ Ted Percival :
... malloc () 'un dönüş değerini atmanıza gerek yok.
Tabii ki haklısın. Kontrol etmem gereken bir K&R kopyası olmasa da bunun her zaman doğru olduğuna inanıyorum .
C'deki örtük dönüştürmelerden pek hoşlanmıyorum, bu yüzden "sihir" i daha görünür kılmak için dökümleri kullanma eğilimindeyim. Bazen okunabilirliğe yardımcı olur, bazen yardım etmez ve bazen derleyici tarafından sessiz bir hatanın yakalanmasına neden olur. Yine de bu konuda şu ya da bu şekilde güçlü bir fikrim yok.
Derleyiciniz C ++ tarzı yorumları anlıyorsa, bu özellikle olasıdır.
Evet ... beni orada yakaladın. C ++ 'da C'den çok daha fazla zaman geçiriyorum. Bunu fark ettiğin için teşekkürler.
C'de aslında iki farklı seçeneğiniz var. Birincisi, sistemin hafızayı sizin için yönetmesine izin verebilirsiniz. Alternatif olarak, bunu kendiniz de yapabilirsiniz. Genellikle, olabildiğince uzun süre öncekine bağlı kalmak istersiniz. Ancak, C'deki otomatik yönetilen bellek son derece sınırlıdır ve aşağıdakiler gibi birçok durumda belleği manuel olarak yönetmeniz gerekecektir:
a. Değişkenin fonksiyonları aşmasını istiyorsunuz ve global değişkene sahip olmak istemiyorsunuz. ör .:
struct pair {
int val;
struct çifti * sonraki;
}
struct pair * new_pair (int val) {
struct çifti * np = malloc (sizeof (struct pair));
np-> val = değer;
np-> sonraki = NULL;
dönüş np;
}
b. dinamik olarak ayrılmış belleğe sahip olmak istiyorsunuz. En yaygın örnek, sabit uzunlukta olmayan dizidir:
int * özel_dizilim; my_special_array = malloc (sizeof (int) * eleman_sayısı); için (i = 0; ic. GERÇEKTEN kirli bir şey yapmak istiyorsun. Örneğin, bir yapının birçok tür veriyi temsil etmesini isterdim ve birleşmeyi sevmiyorum (sendika çok dağınık görünüyor):
struct data { int veri_türü; long data_in_mem; }; struct hayvan {/ * bir şey * /}; struct person {/ * başka bir şey * /}; struct hayvan * read_animal (); struct kişi * read_person (); / * Esas olarak * / struct veri örneği; sampe.data_type = input_type; switch (input_type) { vaka DATA_PERSON: sample.data_in_mem = read_person (); kırmak; durum DATA_ANIMAL: sample.data_in_mem = read_animal (); varsayılan: printf ("Oh hoh! Sizi uyarıyorum, bu tekrar ve işletim sisteminizde hata yapacağım"); }
Bak, uzun bir değer HER ŞEYİ tutmak için yeterlidir. Sadece onu serbest bırakmayı unutma, yoksa pişman olacaksın. Bu, C: D'de eğlenmek için en sevdiğim püf noktaları arasında.
Bununla birlikte, genellikle favori numaralarınızdan (T___T) uzak durmak istersiniz. Çok sık kullanırsanız, er ya da geç işletim sisteminizi bozacaksınız. * Assign and free kullanmadığınız sürece, hala bakire olduğunuzu ve kodun hala güzel göründüğünü söylemek güvenlidir.
Elbette. İçinde kullandığınız kapsamın dışında var olan bir nesne yaratırsanız. İşte uydurma bir örnek (sözdizimimin kapalı olacağını unutmayın; C'm paslanmış, ancak bu örnek yine de kavramı gösterecektir):
class MyClass
{
SomeOtherClass *myObject;
public MyClass()
{
//The object is created when the class is constructed
myObject = (SomeOtherClass*)malloc(sizeof(myObject));
}
public ~MyClass()
{
//The class is destructed
//If you don't free the object here, you leak memory
free(myObject);
}
public void SomeMemberFunction()
{
//Some use of the object
myObject->SomeOperation();
}
};
Bu örnekte, MyClass'ın ömrü boyunca SomeOtherClass türünde bir nesne kullanıyorum. SomeOtherClass nesnesi birkaç işlevde kullanıldığından, belleği dinamik olarak ayırdım: SomeOtherClass nesnesi MyClass oluşturulduğunda oluşturulur, nesnenin ömrü boyunca birkaç kez kullanılır ve ardından MyClass serbest bırakıldığında serbest bırakılır.
Açıkçası, eğer bu gerçek kod olsaydı, myObject'i bu şekilde oluşturmak için (muhtemelen yığın bellek tüketiminin dışında) bir neden olmazdı, ancak bu tür nesne oluşturma / yok etme, çok sayıda nesneye sahip olduğunuzda ve hassas bir şekilde kontrol etmek istediğinizde yararlı hale gelir oluşturulduklarında ve yok edildiklerinde (örneğin, uygulamanız tüm ömrü boyunca 1 GB RAM emmemesi için) ve Pencereli bir ortamda bu, oluşturduğunuz nesneler (diyelim ki düğmeler) gibi hemen hemen zorunludur. , belirli bir işlevin (hatta sınıfın) kapsamının çok dışında var olması gerekir.