Y─▒─č─▒n ve y─▒─č─▒n nerede ve nerede?


Al─▒nan cevaba git


Programlama dil kitaplar─▒ , bu iki ┼čeyin ne oldu─čunu a├ž─▒klamadan y─▒─č─▒nda de─čer tiplerinin yarat─▒ld─▒─č─▒n─▒ ve ├Âbek ├╝zerinde referans t├╝rlerinin yarat─▒ld─▒─č─▒n─▒ a├ž─▒klar. Bununla ilgili net bir a├ž─▒klama okumam─▒┼čt─▒m. Bir y─▒─č─▒n─▒n ne oldu─čunu biliyorum . Fakat,

  • Nerede ve ne (fiziksel olarak ger├žek bir bilgisayar─▒n haf─▒zas─▒nda)?
  • ─░┼čletim sistemi veya dil ├žal─▒┼čma zaman─▒ taraf─▒ndan ne ├Âl├ž├╝de kontrol ediliyorlar?
  • Kapsam─▒ nedir?
  • Her birinin boyutunu ne belirler?
  • Birini daha h─▒zl─▒ yapan nedir?

7814









Cevap say─▒s─▒n─▒ say: 25






Y─▒─č─▒n, bir y├╝r├╝tme i┼č par├žac─▒─č─▒ i├žin ├žizik alan olarak ayarlanan bellektir. Bir i┼člev ├ža─čr─▒ld─▒─č─▒nda, yerel de─či┼čkenler ve baz─▒ defter tutma verileri i├žin y─▒─č─▒n─▒n ├╝st├╝ne bir blok ayr─▒l─▒r. Bu i┼člev d├Ând├╝─č├╝nde, blok kullan─▒lmaz ve bir dahaki i┼člev ├ža─čr─▒ld─▒─č─▒nda kullan─▒labilir. Y─▒─č─▒n her zaman bir LIFO (ilk giren ilk ├ž─▒kar) s─▒ras─▒na ayr─▒l─▒r; en son rezerve edilen blok her zaman serbest b─▒rak─▒lacak bir sonraki bloktur. Bu, y─▒─č─▒n─▒ takip etmeyi ger├žekten kolayla┼čt─▒r─▒yor; bir blo─ču y─▒─č─▒ndan ├ž─▒karmak, bir i┼čaret├žiyi ayarlamaktan ba┼čka bir ┼čey de─čildir.

├ľbek dinamik ay─▒rma i├žin ayr─▒lan bellektir. Y─▒─č─▒n─▒n aksine, bloklar─▒n y─▒─č─▒ndan tahsisine ve ayr─▒lmas─▒na y├Ânelik hi├žbir zorunluluk yoktur; bir blo─ču istedi─činiz zaman tahsis edebilir ve istedi─činiz zaman bo┼čaltabilirsiniz. Bu, herhangi bir zamanda y─▒─č─▒n─▒n hangi b├Âl├╝mlerinin tahsis edildi─čini veya serbest b─▒rak─▒ld─▒─č─▒n─▒ takip etmeyi ├žok daha karma┼č─▒k hale getirir; Farkl─▒ kullan─▒m ┼čekilleri i├žin y─▒─č─▒n performans─▒n─▒ ayarlamak ├╝zere kullan─▒labilen bir├žok ├Âzel y─▒─č─▒n ay─▒r─▒c─▒ vard─▒r.

Her i┼č par├žac─▒─č─▒ bir y─▒─č─▒n al─▒r, ancak uygulama i├žin genellikle yaln─▒zca bir y─▒─č─▒n vard─▒r (farkl─▒ ay─▒rma t├╝rleri i├žin birden fazla y─▒─č─▒n olmas─▒ nadir de─čildir).

Sorular─▒n─▒za do─črudan cevap vermek i├žin:

─░┼čletim sistemi veya dil ├žal─▒┼čma zaman─▒ ne ├Âl├ž├╝de kontrol edilir?

─░┼čletim sistemi, i┼č par├žac─▒─č─▒ olu┼čturuldu─čunda her sistem d├╝zeyinde i┼č par├žac─▒─č─▒ i├žin y─▒─č─▒n─▒ ay─▒r─▒r. Genellikle i┼čletim sistemi, dilimi ├žal─▒┼čma zaman─▒ taraf─▒ndan uygulamaya y─▒─č─▒n ay─▒rmak i├žin ├ža─čr─▒l─▒r.

Kapsam─▒ nedir?

Y─▒─č─▒n bir ipli─če tutturulur, b├Âylece yiv ├ž─▒kt─▒─č─▒nda y─▒─č─▒n geri kazan─▒l─▒r. Y─▒─č─▒n tipik olarak uygulama ba┼člang─▒c─▒nda ├žal─▒┼čma zaman─▒ taraf─▒ndan atan─▒r ve uygulama (teknik olarak i┼člemden) ├ž─▒kt─▒─č─▒nda geri kazan─▒l─▒r.

Her birinin boyutunu ne belirler?

Bir i┼č par├žac─▒─č─▒ olu┼čturuldu─čunda y─▒─č─▒n─▒n boyutu ayarlan─▒r. Y─▒─č─▒n boyutu uygulama ba┼člang─▒c─▒nda ayarlan─▒r, ancak alan gerekti─činde b├╝y├╝yebilir (tahsisat├ž─▒ i┼čletim sisteminden daha fazla bellek ister).

Birini daha h─▒zl─▒ yapan nedir?

Y─▒─č─▒n daha h─▒zl─▒d─▒r, ├ž├╝nk├╝ eri┼čim d├╝zeni bellekten ayr─▒lmay─▒ ve ayr─▒lmas─▒n─▒ ├Ânemsiz k─▒lar (bir i┼čaret├ži / tamsay─▒ basit├že art─▒r─▒l─▒r veya azal─▒r), ├Âb├╝r y─▒─č─▒n ay─▒rma veya ay─▒rma i┼člemine dahil olan ├žok daha karma┼č─▒k defter tutma i┼člemlerine sahiptir. Ayr─▒ca, y─▒─č─▒ndaki her bir bayt ├žok s─▒k kullan─▒lmaya meyillidir; bu i┼člem, i┼člemcinin ├Ânbelle─čiyle e┼čle┼čtirilme e─čiliminde oldu─ču anlam─▒na gelir. ├ľbek i├žin bir ba┼čka performans, ├žo─čunlukla k├╝resel bir kaynak olan ├Âbeklerin tipik olarak ├žoklu i┼č par├žac─▒─č─▒ i├žin g├╝venli olmalar─▒ gerekti─či, yani her tahsis ve deakocation'─▒n programdaki "t├╝m" di─čer ├Âbek eri┼čimleriyle senkronize olmas─▒ gerekti─čidir.

Net bir g├Âsteri:



Resim kayna─č─▒: vikashazrati.wordpress.com


5775







Stack:

  • T─▒pk─▒ y─▒─č─▒n gibi bilgisayar RAM'─▒nda depolan─▒r.
  • Y─▒─č─▒nda olu┼čturulan de─či┼čkenler kapsam d─▒┼č─▒na ├ž─▒kar ve otomatik olarak kald─▒r─▒l─▒r.
  • Y─▒─č─▒ndaki de─či┼čkenlere k─▒yasla ay─▒rmak i├žin ├žok daha h─▒zl─▒.
  • Ger├žek bir y─▒─č─▒n veri yap─▒s─▒ ile uygulan─▒r.
  • Parametre ge├ži┼činde kullan─▒lan yerel verileri, d├Ân├╝┼č adreslerini saklar.
  • ├çok fazla y─▒─č─▒n kullan─▒ld─▒─č─▒nda y─▒─č─▒n ta┼čmas─▒ olabilir (├žo─čunlukla sonsuz veya ├žok fazla ├Âzyinelemeden, ├žok b├╝y├╝k tahsisatlardan).
  • Y─▒─č─▒nda olu┼čturulan veriler i┼čaret├žiler olmadan kullan─▒labilir.
  • Derleme s├╝resinden ├Ânce ne kadar veri ay─▒rman─▒z gerekti─čini tam olarak biliyorsan─▒z y─▒─č─▒n─▒ kullanacaks─▒n─▒z ve ├žok b├╝y├╝k de─čil.
  • Genellikle, program─▒n─▒z ba┼člad─▒─č─▒nda zaten belirlenmi┼č bir maksimum boyut vard─▒r.

Y─▒─č─▒n:

  • Bilgisayar─▒n RAM'─▒nda depolanm─▒┼č gibi.
  • C ++ 'da, y─▒─č─▒ntaki de─či┼čkenler elle imha edilmeli ve asla kapsam d─▒┼č─▒na ├ž─▒kmamal─▒d─▒r. Veri ile serbest delete , delete[] ya da free .
  • Y─▒─č─▒ndaki de─či┼čkenlere k─▒yasla ay─▒rmak i├žin daha yava┼č.
  • Talep ├╝zerine program taraf─▒ndan kullan─▒lmak ├╝zere bir veri blo─ču tahsis etmek i├žin kullan─▒l─▒r.
  • ├çok fazla tahsis ve tahsisat oldu─čunda, par├žalanma olabilir.
  • C ++ veya C'de, ├Âbek ├╝zerinde olu┼čturulan veriler i┼čaret├žiler taraf─▒ndan g├Âsterilecek ve s─▒ras─▒yla new veya ile malloc belirtilecektir.
  • ├çok b├╝y├╝k bir arabellek tahsis edilmesinin istenmesi durumunda tahsisat hatalar─▒ olabilir.
  • ├çal─▒┼čma zaman─▒nda tam olarak ne kadar veriye ihtiya├ž duyaca─č─▒n─▒z─▒ bilmiyorsan─▒z veya ├žok fazla veri ay─▒rman─▒z gerekirse, y─▒─č─▒n─▒ kullan─▒rs─▒n─▒z.
  • Bellek s─▒z─▒nt─▒lar─▒ndan sorumlu.

├ľrnek:

 int foo()
{
  char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).
  bool b = true; // Allocated on the stack.
  if(b)
  {
    //Create 500 bytes on the stack
    char buffer[500];

    //Create 500 bytes on the heap
    pBuffer = new char[500];

   }//<-- buffer is deallocated here, pBuffer is not
}//<--- oops there's a memory leak, I should have called delete[] pBuffer;
 

2269







En ├Ânemli nokta, y─▒─č─▒n ve y─▒─č─▒n─▒n, belle─čin ayr─▒labilece─či yollar i├žin genel terimler olmas─▒d─▒r. Bunlar bir├žok farkl─▒ ┼čekilde uygulanabilir ve terimler temel kavramlara uygulan─▒r.

  • ├ľ─čeler y─▒─č─▒n─▒nda, ├Â─čeler yerle┼čtirildikleri s─▒rayla ├╝st ├╝ste otururlar ve yaln─▒zca ├╝st├╝n├╝ ├ž─▒karabilirsiniz (her ┼čeyi devirmeden).


    Bir ka─č─▒t y─▒─č─▒n─▒ gibi y─▒─č─▒n─▒

    Bir y─▒─č─▒n─▒n basitli─či, ayr─▒lm─▒┼č belle─čin her bir b├Âl├╝m├╝n├╝n kayd─▒n─▒ i├žeren bir tablo tutman─▒za gerek kalmamas─▒d─▒r; ─░htiyac─▒n─▒z olan tek durum bilgisi y─▒─č─▒n─▒n sonuna tek bir i┼čaret├židir. Tahsis etmek ve tahsis etmek i├žin, o tek g├Âstericiyi art─▒rman─▒z ve azaltman─▒z yeterlidir. Not: Bazen bir bellek b├Âl├╝m├╝n├╝n en ba┼č─▒nda ba┼člamak ve yukar─▒ do─čru b├╝y├╝mek yerine a┼ča─č─▒ do─čru uzanmak i├žin bir y─▒─č─▒n uygulanabilir.

  • Bir y─▒─č─▒nda, ├Â─čelerin yerle┼čtirilme ┼čeklini belirli bir d├╝zen yoktur. A├ž─▒k bir '├╝st' ├Â─če olmad─▒─č─▒ndan, herhangi bir s─▒radaki ├Â─čelere ula┼čabilir ve bunlar─▒ kald─▒rabilirsiniz.


    Meyan k├Âk├╝ meyank├Âk├╝

    Y─▒─č─▒n tahsisi, hangi haf─▒zan─▒n tahsis edildi─čine ve neyin ayr─▒lmad─▒─č─▒na dair tam bir kay─▒t tutmay─▒ gerektirir; bunun yan─▒ s─▒ra, par├žalanmay─▒ azaltmak i├žin baz─▒ genel bak─▒m i┼člemleri, istenen boyuta s─▒─čacak kadar b├╝y├╝k biti┼čik haf─▒za b├Âl├╝mleri bulma vb. Bellek, bo┼č alan b─▒rakarak herhangi bir zamanda da─č─▒t─▒labilir. Bazen bir bellek ay─▒r─▒c─▒s─▒, tahsis edilen belle─či etrafa ta┼č─▒yarak belle─či birle┼čtirmek veya ├ž├Âp toplamak gibi i┼člemleri ger├žekle┼čtirir - belle─čin art─▒k kapsam dahilinde olmad─▒─č─▒ ve ├žal─▒┼čma zaman─▒n─▒n kald─▒r─▒laca─č─▒ zaman.

Bu g├Âr├╝nt├╝ler, bir y─▒─č─▒n ve bir y─▒─č─▒nda bellek ay─▒rman─▒n ve bo┼čaltman─▒n iki yolunu a├ž─▒klamak i├žin olduk├ža iyi bir i┼č ├ž─▒karmal─▒d─▒r. Yum!

  • ─░┼čletim sistemi veya dil ├žal─▒┼čma zaman─▒ ne ├Âl├ž├╝de kontrol edilir?

    Belirtildi─či gibi, y─▒─č─▒n ve y─▒─č─▒n genel terimlerdir ve bir├žok ┼čekilde uygulanabilir. Bilgisayar programlar─▒ tipik olarak, hangi fonksiyondan ├ža─čr─▒ld─▒─č─▒n─▒n bir g├Âstericisi ve mevcut de─či┼čkenler gibi mevcut fonksiyonla ilgili bilgileri depolayan bir arama y─▒─č─▒n─▒ ad─▒ verilen bir istif i├žerir. ─░┼člevler, di─čer i┼člevleri ├ža─č─▒r─▒p ard─▒ndan geri d├Ând├╝─č├╝nden, y─▒─č─▒n, i┼člevden gelen bilgileri ├ža─čr─▒ y─▒─č─▒n─▒n─▒n ilerisinde tutmak i├žin b├╝y├╝r ve k├╝├ž├╝l├╝r. Bir program─▒n ger├žekten ├╝zerinde ├žal─▒┼čma zaman─▒ kontrol├╝ yok; programlama dili, i┼čletim sistemi ve hatta sistem mimarisi taraf─▒ndan belirlenir.

    Bir y─▒─č─▒n, dinamik ve rasgele olarak tahsis edilen herhangi bir haf─▒za i├žin kullan─▒lan genel bir terimdir; yani s─▒ra d─▒┼č─▒. Bellek genellikle i┼čletim sistemi taraf─▒ndan tahsis edilir ve bu tahsisi yapmak i├žin API i┼člevlerini ├ža─č─▒ran uygulama kullan─▒l─▒r. Genellikle i┼čletim sistemi taraf─▒ndan i┼členen, dinamik olarak tahsis edilmi┼č belle─či y├Ânetmek i├žin gereken olduk├ža fazla miktarda ek y├╝k vard─▒r.

  • Kapsam─▒ nedir?

    ├ça─čr─▒ y─▒─č─▒n─▒, programlama anlam─▒nda ÔÇťkapsamÔÇŁ ile ilgili olmayan d├╝┼č├╝k seviyeli bir konsepttir. Baz─▒ kodlar─▒ s├Âkerseniz, g├Âreli i┼čaret├ži stilinin y─▒─č─▒n─▒n b├Âl├╝mlerine referanslar─▒ g├Âr├╝rs├╝n├╝z, ancak daha y├╝ksek bir dil s├Âz konusu oldu─čunda, dil kendi kapsam kurallar─▒n─▒ uygular. Bununla birlikte, bir y─▒─č─▒n─▒n ├Ânemli bir y├Ân├╝, bir fonksiyon d├Ând├╝─č├╝nde, bu fonksiyon i├žin yerel olan herhangi bir ┼čeyin istiften hemen kurtar─▒lmas─▒d─▒r. Bu, programlama dillerinin nas─▒l ├žal─▒┼čt─▒─č─▒ g├Âz ├Ân├╝ne al─▒nd─▒─č─▒nda ├žal─▒┼čmas─▒n─▒ bekledi─činiz ┼čekilde ├žal─▒┼č─▒r. Bir y─▒─č─▒n halinde, tan─▒mlanmas─▒ da zordur. Kapsam, i┼čletim sisteminin maruz kald─▒─č─▒ ┼čeydir, ancak programlama diliniz, muhtemelen uygulaman─▒zda "kapsam" ─▒n ne oldu─čuna ili┼čkin kurallar─▒n─▒ ekler. ─░┼člemci mimarisi ve i┼čletim sistemi, i┼člemcinin fiziksel adreslere ├ževirdi─či ve sayfa hatalar─▒ vb. Olan sanal adreslemeyi kullan─▒r. Hangi sayfalar─▒n hangi uygulamalara ait oldu─čunu takip eder. Bununla birlikte, ger├žekte asla endi┼čelenmenize gerek yoktur, ├ž├╝nk├╝ programlama dilinizin belle─či ay─▒rmak ve serbest b─▒rakmak i├žin kulland─▒─č─▒ herhangi bir y├Ântemi kullan─▒rs─▒n─▒z ve hatalar─▒ kontrol eder (ay─▒rma / serbest b─▒rakma herhangi bir nedenle ba┼čar─▒s─▒z olursa).

  • Her birinin boyutunu ne belirler?

    Yine, dile, derleyiciye, i┼čletim sistemine ve mimariye ba─čl─▒d─▒r. Bir y─▒─č─▒n genellikle ├Ânceden tahsis edilir, ├ž├╝nk├╝ tan─▒m─▒ gere─či biti┼čik haf─▒za olmas─▒ gerekir (son paragrafta bunun ├╝zerine daha fazla). Dil derleyici veya i┼čletim sistemi boyutunu belirler. Y─▒─č─▒n ├╝zerinde b├╝y├╝k miktarda veri saklam─▒yorsunuz, bu nedenle istenmeyen sonsuz ├Âzyineleme (bu nedenle, "y─▒─č─▒n ta┼čmas─▒") durumlar─▒ veya di─čer ola─čand─▒┼č─▒ programlama kararlar─▒ d─▒┼č─▒nda, asla tam olarak kullan─▒lmamas─▒ gereken b├╝y├╝kl├╝kte olacakt─▒r.

    Bir y─▒─č─▒n, dinamik olarak tahsis edilebilen herhangi bir ┼čey i├žin genel bir terimdir. Hangi y├Âne bakt─▒─č─▒n─▒za ba─čl─▒ olarak, s├╝rekli boyut de─či┼čtiriyor. Modern i┼člemcilerde ve i┼čletim sistemlerinde tam olarak nas─▒l ├žal─▒┼čt─▒─č─▒ ├žok soyutlanm─▒┼čt─▒r, bu y├╝zden normalde nas─▒l ├žal─▒┼čt─▒─č─▒ konusunda endi┼čelenmenize gerek yoktur, bunun d─▒┼č─▒nda (size izin verdi─či dillerde) bellek kullanmamal─▒s─▒n─▒z Hen├╝z tahsis etmediniz veya bo┼čaltt─▒─č─▒n─▒z haf─▒zay─▒

  • Birini daha h─▒zl─▒ yapan nedir?

    T├╝m bo┼č haf─▒za her zaman biti┼čik oldu─čundan y─▒─č─▒n daha h─▒zl─▒d─▒r. T├╝m bo┼č bellek b├Âl├╝mleri i├žin liste tutulmas─▒ gerekmez, y─▒─č─▒n─▒n o anki ba┼č─▒na sadece bir i┼čaret├ži gelir. Derleyiciler genellikle bu i┼čaret├žiyi bu ama├ž i├žin ├Âzel, h─▒zl─▒ bir kay─▒t defterinde saklar . Dahas─▒, bir y─▒─č─▒n ├╝zerinde sonraki i┼člemler genellikle ├žok yak─▒n seviyedeki bellek alanlar─▒nda yo─čunla┼č─▒r; bu i┼člem ├žok d├╝┼č├╝k bir seviyede i┼člemci kal─▒p ├Ânbelleklerinin optimizasyonu i├žin iyidir.


1338







(Bu cevab─▒, bunun a┼ča─č─▒ yukar─▒ ├žekmi┼č oldu─ču ba┼čka bir soruya ta┼č─▒d─▒m.)

Sorunuzun cevab─▒ uygulamaya ├Âzeldir ve derleyiciler ve i┼člemci mimarileri aras─▒nda de─či┼čebilir. Ancak, burada basitle┼čtirilmi┼č bir a├ž─▒klama.

  • Hem y─▒─č─▒n hem de y─▒─č─▒n, temel i┼čletim sisteminden tahsis edilen bellek alanlar─▒d─▒r (genellikle talep ├╝zerine fiziksel belle─če e┼členen sanal bellek).
  • ├çok i┼č par├žac─▒kl─▒ bir ortamda, her i┼č par├žac─▒─č─▒ kendi tamamen ba─č─▒ms─▒z y─▒─č─▒na sahip olacak, ancak y─▒─č─▒n─▒ payla┼čacak. E┼čzamanl─▒ eri┼čim ├Âbek ├╝zerinde kontrol edilmelidir ve istif ├╝zerinde m├╝mk├╝n de─čildir.

Y─▒─č─▒n

  • ├ľbek, kullan─▒lm─▒┼č ve bo┼č bloklar─▒n ba─člant─▒l─▒ bir listesini i├žerir. Y─▒─č─▒ndaki yeni tahsisler ( new veya s─▒rayla malloc ) serbest bloklardan birinden uygun bir blok olu┼čturularak ger├žekle┼čtirilir. Bu, ├Âbek ├╝zerindeki bloklar─▒n g├╝ncellenmesini gerektirir. ├ľbek ├╝zerindeki bloklar hakk─▒ndaki bu meta bilgi ayr─▒ca ├Âbek ├╝zerinde s─▒k s─▒k her blo─čun hemen ├Ân├╝nde k├╝├ž├╝k bir alanda saklan─▒r.
  • ├ľbek b├╝y├╝d├╝k├že, yeni bloklar genellikle d├╝┼č├╝k adreslerden y├╝ksek adreslere do─čru tahsis edilir. B├Âylece bir ┼čekilde y─▒─č─▒n d├╝┼č├╝nebiliriz y─▒─č─▒n bellek tahsis edilir gibi boyut olarak b├╝y├╝d├╝k├že bellek bloklar─▒n─▒n. E─čer y─▒─č─▒n bir tahsis i├žin ├žok k├╝├ž├╝kse, altta yatan i┼čletim sisteminden daha fazla haf─▒za al─▒narak boyut genellikle artt─▒r─▒labilir.
  • Bir├žok k├╝├ž├╝k blo─čun tahsis edilmesi ve da─č─▒t─▒lmas─▒, y─▒─č─▒n─▒, kullan─▒lm─▒┼č bloklar─▒n aras─▒na serpi┼čtirilmi┼č ├žok say─▒da k├╝├ž├╝k serbest blo─čun bulundu─ču bir durumda b─▒rakabilir. B├╝y├╝k bir blok tahsis etme iste─či ba┼čar─▒s─▒z olabilir, ├ž├╝nk├╝ serbest bloklar─▒n hi├žbiri, serbest bloklar─▒n birle┼čik boyutu yeterince b├╝y├╝k olsa bile, tahsis etme talebini kar┼č─▒layacak kadar b├╝y├╝k de─čildir. Buna y─▒─č─▒n par├žalanmas─▒ denir .
  • Bir serbest blo─ča biti┼čik olan kullan─▒lm─▒┼č bir blok yerinden ├ž─▒kar─▒ld─▒─č─▒nda, yeni serbest blok, y─▒─č─▒n─▒n par├žalanmas─▒n─▒ etkili bir ┼čekilde azaltan daha b├╝y├╝k bir serbest blok olu┼čturmak i├žin biti┼čik serbest blok ile birle┼čtirilebilir.


Y─▒─č─▒n

Y─▒─č─▒n─▒

  • Y─▒─č─▒n ├žo─ču zaman y─▒─č─▒n g├Âstericisi olarak adland─▒r─▒lan CPU ├╝zerindeki ├Âzel bir sicile ├žal─▒┼č─▒r . Ba┼člang─▒├žta y─▒─č─▒n i┼čaret├žisi, y─▒─č─▒n─▒n ├╝st├╝ne i┼čaret eder (y─▒─č─▒ndaki en y├╝ksek adres).
  • CPU, de─čerleri y─▒─č─▒na itmek ve y─▒─č─▒ndan geri a├žmak i├žin ├Âzel talimatlara sahiptir . Her basma , de─čeri y─▒─č─▒n i┼čaret├žisinin ge├žerli konumunda saklar ve y─▒─č─▒n i┼čaret├žisini azalt─▒r. Bir pop , y─▒─č─▒n i┼čaret├žisinin g├Âsterdi─či de─čeri al─▒r ve ard─▒ndan y─▒─č─▒n i┼čaret├žisini art─▒r─▒r (y─▒─č─▒na bir de─čer eklemenin , y─▒─č─▒n i┼čaret├žisini d├╝┼č├╝rd├╝─č├╝ ve bir de─čerin kald─▒r─▒lmas─▒n─▒n , de─čeri artt─▒rd─▒─č─▒ ger├že─či ile kar─▒┼čt─▒r─▒lmay─▒n . alt). Depolanan ve al─▒nan de─čerler CPU kay─▒tlar─▒n─▒n de─čerleridir.
  • Bir i┼člev ├ža─čr─▒ld─▒─č─▒nda, CPU ge├žerli komut g├Âstergesini iten ├Âzel komutlar kullan─▒r , yani y─▒─č─▒n ├╝zerinde ├žal─▒┼čan kodun adresi. CPU daha sonra komut g├Âstergesini ├ža─č─▒r─▒lan i┼člevin adresine ayarlayarak i┼čleve atlar. Daha sonra, fonksiyon geri d├Ând├╝─č├╝nde, eski komut g├Âsterici y─▒─č─▒ndan ├ž─▒kar ve ├žal─▒┼čt─▒rma fonksiyondan ├ža─čr─▒ld─▒ktan hemen sonra kodda devam eder.
  • Bir fonksiyon girildi─činde, y─▒─č─▒n i┼čaret├žisi yerel (otomatik) de─či┼čkenler i├žin y─▒─č─▒na daha fazla yer ay─▒rmak ├╝zere azalt─▒l─▒r. Fonksiyonun bir yerel 32 bit de─či┼čkeni varsa, d├Ârt bayt y─▒─č─▒nda bir kenara konulur. ─░┼člev d├Ând├╝─č├╝nde, y─▒─č─▒n i┼čaret├žisi ayr─▒lm─▒┼č alan─▒ serbest b─▒rakmak i├žin geri hareket ettirilir.
  • Bir i┼člevin parametreleri varsa, bunlar i┼čleve ├ža─čr─▒lmadan ├Ânce y─▒─č─▒na itilir. ─░┼člevdeki kod daha sonra bu de─čerleri bulmak i├žin ge├žerli y─▒─č─▒n i┼čaret├žisinden y─▒─č─▒nda dola┼čabilir.
  • Yerle┼čtirme i┼člevi ├ža─čr─▒lar─▒ bir cazibe i┼člevi g├Âr├╝r. Her yeni ├ža─čr─▒, i┼člev parametreleri, yerel adresler i├žin d├Ân├╝┼č adresi ve alan tahsis edecek ve bu etkinle┼čtirme kay─▒tlar─▒ i├ž i├že aramalar i├žin istiflenebilir ve i┼člevler geri d├Ând├╝─č├╝nde do─čru ┼čekilde a├ž─▒lacakt─▒r.
  • Y─▒─č─▒n s─▒n─▒rl─▒ bir bellek blo─ču oldu─čundan, ├žok fazla i├ž i├že ge├žmi┼č i┼člev ├ža─č─▒rarak ve / veya yerel de─či┼čkenler i├žin ├žok fazla alan ay─▒rarak y─▒─č─▒n ta┼čmas─▒na neden olabilirsiniz . Genellikle y─▒─č─▒n i├žin kullan─▒lan bellek alan─▒, y─▒─č─▒n─▒n alt─▒na (en d├╝┼č├╝k adres) yazman─▒n CPU'da bir tuzak veya istisna tetikleyece─či ┼čekilde kurulur. Bu istisnai durum daha sonra ├žal─▒┼čma zaman─▒ taraf─▒ndan yakalanabilir ve bir t├╝r y─▒─č─▒n ta┼čmas─▒ istisnas─▒na d├Ân├╝┼čt├╝r├╝lebilir.


Y─▒─č─▒n─▒

Bir y─▒─č─▒n yerine ├Âbek ├╝zerinde bir i┼člev atanabilir mi?

Hay─▒r, i┼člevler i├žin etkinle┼čtirme kay─▒tlar─▒ (yani yerel veya otomatik de─či┼čkenler), yaln─▒zca bu de─či┼čkenleri saklamak i├žin de─čil, ayn─▒ zamanda i├ž i├že ge├žmi┼č i┼člev ├ža─čr─▒lar─▒n─▒ takip etmek i├žin kullan─▒lan y─▒─č─▒nda da tahsis edilir.

Y─▒─č─▒n nas─▒l y├Ânetilir ger├žekten ├žal─▒┼čma zaman─▒ ortam─▒na kalm─▒┼č. C kullan─▒r malloc ve C ++ kullan─▒r new , ancak di─čer bir├žok dilde ├ž├Âp toplama vard─▒r.

Ancak, y─▒─č─▒n i┼člemci mimarisine yak─▒ndan ba─čl─▒ daha d├╝┼č├╝k bir ├Âzelliktir. Yeterince yer olmad─▒─č─▒ zaman ├Âbek b├╝y├╝tmek ├žok zor de─čildir, ├ž├╝nk├╝ ├Âbekleri i┼čleyen k├╝t├╝phane ├ža─čr─▒s─▒nda uygulanabilir. Bununla birlikte, y─▒─č─▒n─▒ b├╝y├╝tmek ├žo─ču zaman imkans─▒zd─▒r ├ž├╝nk├╝ y─▒─č─▒n ta┼čmas─▒ yaln─▒zca ├žok ge├ž oldu─čunda ortaya ├ž─▒kar; ve y├╝r├╝tme ipli─činin kapat─▒lmas─▒ tek uygulanabilir se├ženektir.


705







A┼ča─č─▒daki C # kodunda

 public void Method1()
{
    int i = 4;
    int y = 2;
    class1 cls1 = new class1();
}
 

─░┼čte haf─▒zan─▒n nas─▒l y├Ânetildi─či


Y─▒─č─▒ndaki de─či┼čkenlerin resmi

Local Variables Bu sadece fonksiyon ├ža─čr─▒s─▒ y─▒─č─▒nda gitti─či s├╝rece devam etmesi gerekir. ├ľbek, ya┼čam boyu ger├žekten tan─▒mad─▒─č─▒m─▒z ancak bir s├╝re dayanmalar─▒n─▒ bekledi─čimiz de─či┼čkenler i├žin kullan─▒l─▒r. ├ço─ču dilde, derleme s─▒ras─▒nda bir de─či┼čkenin y─▒─č─▒nda depolanmas─▒ istendi─činde ne kadar b├╝y├╝k oldu─čunu bilmemiz kritik ├Ânem ta┼č─▒r.

Nesneler (bunlar─▒ g├╝ncelledik├že boyut olarak de─či┼čir) ├Âbek ├╝zerinde dururlar, ├ž├╝nk├╝ olu┼čturma zaman─▒nda ne kadar dayanacaklar─▒n─▒ bilmiyoruz. Bir├žok dilde, art─▒k referanslar─▒ olmayan nesneleri (cls1 nesnesi gibi) bulmak i├žin y─▒─č─▒n toplan─▒r.

Java'da ├žo─ču nesne do─črudan y─▒─č─▒na gider. C / C ++ gibi dillerde, i┼čaret├žilerle ilgilenmedi─činizde yap─▒lar ve s─▒n─▒flar genellikle y─▒─č─▒nda kalabilir.

Daha fazla bilgi burada bulunabilir:

Y─▒─č─▒n ve y─▒─č─▒n bellek tahsisi aras─▒ndaki fark ┬źtimmurphy.org

ve burada:

Y─▒─č─▒n ve ├ľbek ├ťzerinde Nesneler Olu┼čturma

Bu makale yukar─▒daki resmin kayna─č─▒d─▒r: Alt─▒ ├Ânemli .NET kavram─▒: Y─▒─č─▒n, y─▒─č─▒n, de─čer tipleri, referans tipleri, kutulama ve kutudan ├ž─▒karma - CodeProject

ancak baz─▒ yanl─▒┼čl─▒klar i├žerebilece─čini unutmay─▒n.


392







Y─▒─č─▒n Bir i┼člevi ├ža─č─▒rd─▒─č─▒n─▒zda, o i┼člevin arg├╝manlar─▒ art─▒ ba┼čka bir ek y├╝k de y─▒─č─▒n─▒n ├╝st├╝ne yerle┼čtirilir. Baz─▒ bilgiler (├Ârne─čin, nereye gidece─činiz gibi) orada da saklan─▒r. ─░┼čleviniz i├žinde bir de─či┼čken bildirdi─činizde, bu de─či┼čken y─▒─č─▒nda da tahsis edilir.

Y─▒─č─▒n─▒n yeniden da─č─▒t─▒lmas─▒ olduk├ža basittir ├ž├╝nk├╝ ay─▒rd─▒─č─▒n─▒z ters s─▒rada her zaman ay─▒rman─▒z gerekir. ─░┼člevlere girerken y─▒─č─▒n ├Â─čeleri eklenir, siz ├ž─▒kt─▒k├ža kar┼č─▒l─▒k gelen veriler kald─▒r─▒l─▒r. Bu, ├žok say─▒da ba┼čka i┼člev ├ža─č─▒ran (ya da ├Âzyinelemeli bir ├ž├Âz├╝m olu┼čturan) ├žok say─▒da i┼člev ├ža─č─▒rmad─▒─č─▒n─▒z s├╝rece, y─▒─č─▒n─▒n k├╝├ž├╝k bir b├Âlgesinde kalma e─čiliminde oldu─čunuz anlam─▒na gelir.

Y─▒─č─▒n Y─▒─č─▒n, olu┼čturdu─čunuz verileri an─▒nda koydu─čunuz yerin genel ad─▒d─▒r. Program─▒n─▒z─▒n ka├ž uzay gemisi olu┼čturaca─č─▒n─▒ bilmiyorsan─▒z, her bir uzay gemisi olu┼čturmak i├žin yeni (veya malloc veya e┼čde─čeri) operat├Âr├╝n├╝ kullanman─▒z olas─▒d─▒r. Bu tahsis bir s├╝re etrafta kalacak, bu y├╝zden yaratt─▒klar─▒m─▒zdan farkl─▒ bir d├╝zende ┼čeyleri serbest b─▒rakaca─č─▒z.

Bu nedenle, y─▒─č─▒n ├žok daha karma┼č─▒kt─▒r, ├ž├╝nk├╝ sonunda, kullan─▒lmayan bellek b├Âlgeleri bulunur - bunlar bellek par├žalar─▒ par├žalan─▒r. ─░htiyac─▒n─▒z olan boyutta bo┼č haf─▒za bulmak zor bir problemdir. Bu y├╝zden y─▒─č─▒ntan ka├ž─▒n─▒lmas─▒ gerekir (yine de s─▒kl─▒kla kullan─▒lmas─▒na ra─čmen).

Uygulama Y─▒─č─▒n ve y─▒─č─▒n─▒n uygulanmas─▒ genellikle ├žal─▒┼čma zaman─▒na / i┼čletim sistemine ba─čl─▒d─▒r. Genellikle oyunlar ve performans a├ž─▒s─▒ndan kritik olan di─čer uygulamalar, y─▒─č─▒ndan b├╝y├╝k miktarda bellek alan kendi bellek ├ž├Âz├╝mlerini olu┼čturur ve daha sonra i┼čletim sistemine bellek g├╝venmekten ka├ž─▒nmak i├žin dahili olarak t├╝ketir.

Bu, yaln─▒zca bellek kullan─▒m─▒n─▒z─▒n normdan olduk├ža farkl─▒ olmas─▒ durumunda pratiktir - yani, b├╝y├╝k bir operasyonda bir seviye y├╝kledi─činiz ve her ┼čeyi ba┼čka bir b├╝y├╝k operasyonda ├Ât├╝rebilece─činiz oyunlar i├žin.

Bellekteki fiziksel konum Bu, program─▒n─▒z─▒n, fiziksel verilerin ba┼čka bir yerde oldu─ču (sabit diskte bile!) Belirli bir adrese eri┼čiminiz oldu─čunu d├╝┼č├╝nmesini sa─člayan Sanal Bellek ad─▒ verilen bir teknoloji nedeniyle d├╝┼č├╝nd├╝─č├╝n├╝zden daha az ilgilidir . Arama a─čac─▒n─▒z derinle┼čtik├že, y─▒─č─▒n i├žin ald─▒─č─▒n─▒z adresler artan s─▒radad─▒r. Y─▒─č─▒n i├žin adresler tahmin edilemez (yani belirli bir uygulama ┼čeklinde) ve a├ž─▒k├žas─▒ ├Ânemli de─čil.


201







A├ž─▒kl─▒─ča kavu┼čturmak i├žin bu cevab─▒n yanl─▒┼č bir bilgisi var ( Thomas yorumlardan sonra cevab─▒n─▒ d├╝zeltti :)). Di─čer cevaplar sadece statik tahsisat─▒n ne demek oldu─čunu a├ž─▒klamaktan ka├ž─▒n─▒r. Bu y├╝zden, ├╝├ž ana tahsisat ┼čeklini ve bunlar─▒n genellikle y─▒─č─▒n, y─▒─č─▒n ve veri segmentiyle nas─▒l ili┼čkili oldu─čunu a├ž─▒klayaca─č─▒m. Ayr─▒ca, insanlar─▒n anlamalar─▒na yard─▒mc─▒ olmak i├žin hem C / C ++ hem de Python'da baz─▒ ├Ârnekler g├Âsterece─čim.

"Statik" (AKA statik olarak tahsis edilmi┼čtir) de─či┼čkenleri y─▒─č─▒nda tahsis edilmemi┼čtir. Bunu varsaymay─▒n - bir├žok insan sadece ÔÇťstatikÔÇŁ ÔÇťy─▒─č─▒nÔÇŁ gibi ses ├ž─▒kard─▒─č─▒ i├žin yapar. Asl─▒nda ne y─▒─č─▒nda ne de y─▒─č─▒nda varlar. Veri segmenti olarak adland─▒r─▒lan─▒n bir par├žas─▒ .

Bununla birlikte, genellikle "y─▒─č─▒n" ve "y─▒─č─▒n" yerine " kapsam " ve " ├Âm├╝r " hakk─▒nda d├╝┼č├╝nmek daha iyidir.

Kapsam, kodun hangi b├Âl├╝mlerinin bir de─či┼čkene eri┼čebilece─čini belirtir. Genel olarak, kapsam─▒ daha karma┼č─▒k hale getirebilse de , yerel kapsam─▒ (yaln─▒zca mevcut i┼člevle eri┼čilebilir), genel kapsam─▒ (her yerden eri┼čilebilir) bulabiliriz.

├ľm├╝r boyu, program─▒n ├žal─▒┼čmas─▒ s─▒ras─▒nda bir de─či┼čken tahsis edildi─činde ve ├ž─▒kar─▒ld─▒─č─▒ zaman anlam─▒na gelir. Genellikle statik tahsisat─▒n (de─či┼čken program─▒n t├╝m s├╝resi boyunca devam eder, ayn─▒ bilgiyi birka├ž i┼člev ├ža─čr─▒s─▒nda saklamak i├žin faydal─▒ k─▒lar) otomatik tahsise kar┼č─▒ (de─či┼čken sadece bir fonksiyona yap─▒lan tek bir ├ža─čr─▒ s─▒ras─▒nda devam eder, onu i┼člevsellik i├žin kullan─▒r.) yaln─▒zca i┼čleviniz s─▒ras─▒nda kullan─▒lan ve tamamland─▒ktan sonra at─▒labilen bilgileri dinamik ay─▒rmaya (statik veya otomatik gibi derleme zaman─▒ yerine, ├žal─▒┼čma zaman─▒nda tan─▒mlanm─▒┼č de─či┼čkenler ) kar┼č─▒ saklamak .

Her ne kadar ├žo─ču derleyici ve yorumlay─▒c─▒ bu davran─▒┼č─▒ istif, y─▒─č─▒n vb. Kullanmaya benzer ┼čekilde uygulasa da, bir derleyici bazen davran─▒┼člar─▒n do─čru olmas─▒ isteniyorsa bu kurallar─▒ bozabilir. ├ľrne─čin, optimizasyon nedeniyle bir yerel de─či┼čken yaln─▒zca bir kay─▒t defterinde bulunabilir veya ├žo─ču yerel de─či┼čken y─▒─č─▒nda bulunsa bile tamamen kald─▒r─▒labilir. Birka├ž yorumda belirtildi─či gibi, bir y─▒─č─▒n veya bir y─▒─č─▒n bile kullanmayan bir derleyiciyi kullanmakta ├Âzg├╝rs├╝n├╝z, bunun yerine ba┼čka baz─▒ depolama mekanizmalar─▒ (nadiren yap─▒l─▒r, ├ž├╝nk├╝ y─▒─č─▒nlar ve y─▒─č─▒nlar bunun i├žin m├╝kemmeldir).

Bunlar─▒ a├ž─▒klamak i├žin baz─▒ basit a├ž─▒klamal─▒ C kodlar─▒ verece─čim. ├ľ─črenmenin en iyi yolu, bir program─▒ hata ay─▒klay─▒c─▒ alt─▒nda ├žal─▒┼čt─▒rmak ve davran─▒┼č─▒ izlemektir. Python okumay─▒ tercih ediyorsan─▒z, cevab─▒n sonuna atlay─▒n :)

 // Statically allocated in the data segment when the program/DLL is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in the code
int someGlobalVariable;

// Statically allocated in the data segment when the program is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in this particular code file
static int someStaticVariable;

// "someArgument" is allocated on the stack each time MyFunction is called
// "someArgument" is deallocated when MyFunction returns
// scope - can be accessed only within MyFunction()
void MyFunction(int someArgument) {

    // Statically allocated in the data segment when the program is first loaded
    // Deallocated when the program/DLL exits
    // scope - can be accessed only within MyFunction()
    static int someLocalStaticVariable;

    // Allocated on the stack each time MyFunction is called
    // Deallocated when MyFunction returns
    // scope - can be accessed only within MyFunction()
    int someLocalVariable;

    // A *pointer* is allocated on the stack each time MyFunction is called
    // This pointer is deallocated when MyFunction returns
    // scope - the pointer can be accessed only within MyFunction()
    int* someDynamicVariable;

    // This line causes space for an integer to be allocated in the heap
    // when this line is executed. Note this is not at the beginning of
    // the call to MyFunction(), like the automatic variables
    // scope - only code within MyFunction() can access this space
    // *through this particular variable*.
    // However, if you pass the address somewhere else, that code
    // can access it too
    someDynamicVariable = new int;


    // This line deallocates the space for the integer in the heap.
    // If we did not write it, the memory would be "leaked".
    // Note a fundamental difference between the stack and heap
    // the heap must be managed. The stack is managed for us.
    delete someDynamicVariable;

    // In other cases, instead of deallocating this heap space you
    // might store the address somewhere more permanent to use later.
    // Some languages even take care of deallocation for you... but
    // always it needs to be taken care of at runtime by some mechanism.

    // When the function returns, someArgument, someLocalVariable
    // and the pointer someDynamicVariable are deallocated.
    // The space pointed to by someDynamicVariable was already
    // deallocated prior to returning.
    return;
}

// Note that someGlobalVariable, someStaticVariable and
// someLocalStaticVariable continue to exist, and are not
// deallocated until the program exits.
 

├ľm├╝r boyu ve kapsam─▒ aras─▒nda ayr─▒m yapman─▒n neden ├Ânemli oldu─čuna dair belirgin bir ├Ârnek, bir de─či┼čkenin yerel kapsam─▒ olabilir, ancak statik ├Âmre sahip olabilir - ├Ârne─čin, yukar─▒daki kod ├Ârne─činde "someLocalStaticVariable". Bu t├╝r de─či┼čkenler ortak ancak resmi olmayan adland─▒rma al─▒┼čkanl─▒klar─▒m─▒z─▒ kafa kar─▒┼čt─▒r─▒c─▒ hale getirebilir. ├ľrne─čin, " yerel " dedi─čimizde, genellikle " yerel olarak kapsaml─▒ otomatik olarak atanm─▒┼č de─či┼čken " anlam─▒na gelir ve genel derken genellikle " genel olarak statik olarak atanm─▒┼č de─či┼čken " anlam─▒na gelir . Ne yaz─▒k ki, " dosya statik olarak tahsis edilmi┼č de─či┼čkenleri kapsamal─▒ " gibi ┼čeyler s├Âz konusu oldu─čunda, pek ├žok insan sadece ... " huh ??? ".

C / C ++ 'daki s├Âzdizimi se├ženeklerinin baz─▒lar─▒ bu sorunu daha da artt─▒rmaktad─▒r - ├Ârne─čin, bir├žok ki┼či global de─či┼čkenlerin a┼ča─č─▒da g├Âsterilen s├Âzdizimi nedeniyle "statik" olmad─▒─č─▒n─▒ d├╝┼č├╝nmektedir.

 int var1; // Has global scope and static allocation
static int var2; // Has file scope and static allocation

int main() {return 0;}
 

Yukar─▒daki bildirime "statik" anahtar kelimesini koyman─▒n, var2'nin k├╝resel kapsamda olmas─▒n─▒ engelledi─čine dikkat edin. Bununla birlikte, global var1 statik tahsise sahiptir. Bu sezgisel de─čil! Bu nedenle, kapsam─▒ tan─▒mlarken asla "statik" kelimesini kullanmaya ├žal─▒┼čmam ve bunun yerine "dosya" veya "dosya s─▒n─▒rl─▒" kapsam─▒ gibi bir ┼čey demeye ├žal─▒┼č─▒yorum. Ancak bir├žok ki┼či, yaln─▒zca bir kod dosyas─▒ndan eri┼čilebilen bir de─či┼čkeni tan─▒mlamak i├žin "statik" veya "statik kapsam" ifadesini kullan─▒r. ├ľm├╝r boyu ba─člam─▒nda, "statik" her zaman de─či┼čkenin program ba┼člang─▒c─▒nda tahsis edildi─či ve program ├ž─▒kt─▒─č─▒nda tahsis edilmedi─či anlam─▒na gelir.

Baz─▒ insanlar bu kavramlar─▒ C / C ++ 'ya ├Âzg├╝ olarak d├╝┼č├╝n├╝r. Onlar de─čil. ├ľrne─čin, a┼ča─č─▒daki Python ├Ârne─či, ├╝├ž tahsis t├╝r├╝n├╝n hepsini g├Âstermektedir (yorumlanm─▒┼č dillerde buraya girmeyece─čim baz─▒ ince farkl─▒l─▒klar olabilir).

 from datetime import datetime

class Animal:
    _FavoriteFood = 'Undefined' # _FavoriteFood is statically allocated

    def PetAnimal(self):
        curTime = datetime.time(datetime.now()) # curTime is automatically allocatedion
        print("Thank you for petting me. But it's " + str(curTime) + ", you should feed me. My favorite food is " + self._FavoriteFood)

class Cat(Animal):
    _FavoriteFood = 'tuna' # Note since we override, Cat class has its own statically allocated _FavoriteFood variable, different from Animal's

class Dog(Animal):
    _FavoriteFood = 'steak' # Likewise, the Dog class gets its own static variable. Important to note - this one static variable is shared among all instances of Dog, hence it is not dynamic!


if __name__ == "__main__":
    whiskers = Cat() # Dynamically allocated
    fido = Dog() # Dynamically allocated
    rinTinTin = Dog() # Dynamically allocated

    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

    Dog._FavoriteFood = 'milkbones'
    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

# Output is:
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is milkbones
# Thank you for petting me. But it's 13:05:02.256000, you should feed me. My favorite food is milkbones
 

185







Di─čerleri geni┼č vuru┼člara olduk├ža iyi cevap verdiler, bu y├╝zden birka├ž detay verece─čim.

  1. Y─▒─č─▒n ve y─▒─č─▒n─▒n tekil olmas─▒ gerekmez. Birden fazla y─▒─č─▒n─▒n oldu─ču ortak bir durum, bir i┼člemde birden fazla i┼č par├žac─▒─č─▒n─▒z─▒n bulunmas─▒d─▒r. Bu durumda, her i┼č par├žac─▒─č─▒n─▒n kendi y─▒─č─▒n─▒ vard─▒r. Birden fazla ├Âbe─če de sahip olabilirsiniz, ├Ârne─čin baz─▒ DLL yap─▒land─▒rmalar─▒ farkl─▒ y─▒─č─▒nlardan farkl─▒ DLL'lerin ayr─▒lmas─▒na neden olabilir, bu y├╝zden farkl─▒ bir k├╝t├╝phane taraf─▒ndan ayr─▒lan belle─či serbest b─▒rakmak genellikle k├Ât├╝ bir fikirdir.

  2. C'de , y─▒─č─▒nda tahsis eden, ├Âbek ├╝zerinde tahsis edilen, yerine y─▒─č─▒nda tahsis eden allolar─▒n kullan─▒lmas─▒ ile de─či┼čken uzunluk tahsisinden faydalanabilirsiniz . Bu bellek return ifadenizden kurtulmaz, ancak bir ├žizik tamponu i├žin kullan─▒┼čl─▒d─▒r.

  3. Windows'ta fazla kullanmad─▒─č─▒n─▒z b├╝y├╝k bir ge├žici arabellek yapmak ├╝cretsiz de─čildir. Bunun nedeni, derleyicinin, y─▒─č─▒n─▒n var oldu─čundan emin olmak i├žin i┼člevinize her girdi─činizde ├ža─čr─▒lan bir y─▒─č─▒n prob d├Âng├╝s├╝ ├╝retmesidir (├ž├╝nk├╝ Windows, y─▒─č─▒n─▒n ne zaman b├╝y├╝mesi gerekti─čini alg─▒lamak i├žin y─▒─č─▒n─▒z─▒n sonunda tek bir koruma sayfas─▒ kullan─▒r. Belle─če y─▒─č─▒n─▒n ucundan birden fazla sayfa eri┼čirseniz kilitleneceksiniz). ├ľrnek:

 void myfunction()
{
   char big[10000000];
   // Do something that only uses for first 1K of big 99% of the time.
}
 

164







Di─čerleri do─črudan sorunuzu cevaplad─▒, ancak y─▒─č─▒n─▒ ve ├Âbekleri anlamaya ├žal─▒┼č─▒rken, geleneksel bir UNIX i┼čleminin (mizanpaja dayal─▒ mmap() tahsisat├ž─▒lar olmadan) bellek d├╝zenini d├╝┼č├╝nmenin yararl─▒ olaca─č─▒n─▒ d├╝┼č├╝n├╝yorum . Bellek Y├Ânetimi S├Âzl├╝─č├╝ web sayfas─▒ bu haf─▒za d├╝zeninin bir sahiptir.

Y─▒─č─▒n ve ├Âbek geleneksel olarak i┼člemin sanal adres alan─▒n─▒n kar┼č─▒t u├žlar─▒na yerle┼čtirilir. Y─▒─č─▒na eri┼čildi─činde, ├žekirdek taraf─▒ndan ayarlanan bir boyuta kadar (otomatik olarak ayarlanabilir setrlimit(RLIMIT_STACK, ...) ) otomatik olarak b├╝y├╝r . Bellek ay─▒r─▒c─▒s─▒, brk() ya da sbrk() sistem ├ža─čr─▒s─▒n─▒ ba┼člatt─▒─č─▒nda, i┼člemin sanal adres alan─▒na daha fazla fiziksel bellek sayfas─▒ e┼čle┼čtirildi─činde y─▒─č─▒n b├╝y├╝r .

Baz─▒ g├Âm├╝l├╝ sistemler gibi sanal belle─či olmayan sistemlerde, ayn─▒ temel d├╝zen genellikle y─▒─č─▒n ve y─▒─č─▒n─▒n boyutunda sabitlenmesi d─▒┼č─▒nda uygulan─▒r. Bununla birlikte, di─čer g├Âm├╝l├╝ sistemlerde (Microchip PIC mikro denetleyicilerini temel alan sistemler gibi), program y─▒─č─▒n─▒, veri hareketi y├Ânergeleri taraf─▒ndan adreslenemeyen ayr─▒ bir bellek blo─čudur ve yaln─▒zca program ak─▒┼č y├Ânergeleri yoluyla dolayl─▒ olarak de─či┼čtirilebilir veya okunabilir (├ža─čr─▒, geri d├Ân├╝┼č, vb.) Intel Itanium i┼člemciler gibi di─čer mimarilerde birden fazla y─▒─č─▒n var . Bu anlamda, y─▒─č─▒n CPU mimarisinin bir eleman─▒d─▒r.


131


2008-09-17





Y─▒─č─▒n, 'pop' (y─▒─č─▒ndan bir de─čer ├ž─▒kar ve d├Ând├╝r) ve 'basma' (y─▒─č─▒na bir de─čer it) gibi birka├ž ana derleme dili y├Ânergesiyle manip├╝le edilebilecek bir bellek par├žas─▒d─▒r, ancak ayn─▒ zamanda ├ža─čr─▒ yap─▒n ( Bir alt yordam ├ža─čr─▒s─▒ - bu, y─▒─č─▒na geri d├Ânmek i├žin adresi iter) ve geri d├Ânmek (bir alt yordamdan geri d├Ânmek - bu, adresi y─▒─č─▒ndan ├ž─▒kar ve ona atlar). ─░stenilen ┼čekilde ayarlanabilen y─▒─č─▒n g├Âstericisi yazmac─▒n─▒n alt─▒ndaki bellek b├Âlgesidir. Y─▒─č─▒n, arg├╝manlar─▒ alt yordamlara ge├žirmek ve ayr─▒ca alt yordamlar─▒ ├ža─č─▒rmadan ├Ânce kay─▒tlardaki de─čerleri korumak i├žin de kullan─▒l─▒r.

├ľbek, i┼čletim sistemi taraf─▒ndan bir uygulamaya, tipik olarak malloc benzeri bir sistem arac─▒l─▒─č─▒yla verilen belle─čin bir k─▒sm─▒d─▒r. Modern i┼čletim sistemlerinde bu bellek yaln─▒zca arama i┼čleminin eri┼čebildi─či bir sayfalar k├╝mesidir.

Y─▒─č─▒n─▒n boyutu ├žal─▒┼čma zaman─▒nda belirlenir ve genellikle program ba┼člad─▒ktan sonra b├╝y├╝mez. Bir C program─▒nda, istifin her fonksiyonda bildirilen her de─či┼čkeni tutacak kadar b├╝y├╝k olmas─▒ gerekir. Y─▒─č─▒n gerekti─činde dinamik olarak b├╝y├╝yecek, ancak i┼čletim sistemi nihayetinde ├ža─čr─▒ yapacak (├Âbekleri malloc taraf─▒ndan istenen de─čerden daha fazla b├╝y├╝yecek, en az─▒ndan baz─▒ gelecekteki malloclar─▒n ├žekirde─če geri d├Ânmesi gerekmeyecek) Daha fazla haf─▒za kazan─▒n.Bu davran─▒┼č genellikle ├Âzelle┼čtirilebilir)

Program─▒ ba┼člatmadan ├Ânce y─▒─č─▒n─▒ tahsis etti─činiz i├žin, y─▒─č─▒n─▒ kullanmadan ├Ânce malloc'la u─čra┼čman─▒za gerek kalmaz, bu y├╝zden orada k├╝├ž├╝k bir avantaj. Uygulamada sanal bellek alt sistemlerine sahip modern i┼čletim sistemlerinde neyin h─▒zl─▒ ve neyin yava┼č olaca─č─▒n─▒ tahmin etmek ├žok zordur, ├ž├╝nk├╝ sayfalar─▒n nas─▒l uyguland─▒─č─▒ ve nerede depoland─▒klar─▒ bir uygulama detay─▒d─▒r.


112







Bence bu konuda bir├žok ba┼čka insan size do─čru cevaplar verdi.

Ancak ka├ž─▒r─▒lan bir detay, "y─▒─č─▒n" ─▒n asl─▒nda "serbest ma─čaza" olarak adland─▒r─▒lmas─▒ gerekti─čidir. Bu ayr─▒m─▒n nedeni, orijinal serbest ma─čazan─▒n "binom y─▒─č─▒n─▒" olarak bilinen bir veri yap─▒s─▒ ile ger├žekle┼čtirilmi┼č olmas─▒d─▒r. Bu nedenle, malloc () / free () 'nin erken uygulamalar─▒ndan tahsis bir y─▒─č─▒ntan tahsis edildi. Bununla birlikte, bu modern g├╝nde, ├žo─ču ├╝cretsiz ma─čaza binom y─▒─č─▒nlar─▒ olmayan ├žok ayr─▒nt─▒l─▒ veri yap─▒lar─▒yla uygulanmaktad─▒r.


111


2008-09-17





Bir y─▒─č─▒n nedir?

Bir y─▒─č─▒n, tipik olarak ├Âzenle d├╝zenlenmi┼č bir nesne y─▒─č─▒n─▒d─▒r.


Resim tan─▒m─▒n─▒ buraya girin

Bilgi i┼člem mimarilerindeki y─▒─č─▒nlar, verilerin ilk giren ilk ├ž─▒kar y├Ântemiyle eklendi─či veya ├ž─▒kar─▒ld─▒─č─▒ bellek b├Âlgeleridir.
├çok i┼č par├žac─▒kl─▒ bir uygulamada, her i┼č par├žac─▒─č─▒n─▒n kendi y─▒─č─▒n─▒na sahip olacakt─▒r.

Bir y─▒─č─▒n nedir?

Bir y─▒─č─▒n, ba┼č─▒bo┼č bir ┼čekilde biriktirilmi┼č olan d├╝zensiz ┼čeyler toplulu─čudur.


Resim tan─▒m─▒n─▒ buraya girin

Bilgi i┼člem mimarilerinde y─▒─č─▒n, i┼čletim sistemi veya bellek y├Âneticisi k├╝t├╝phanesi taraf─▒ndan otomatik olarak y├Ânetilen dinamik olarak ayr─▒lm─▒┼č bir bellek alan─▒d─▒r.
├ľbek ├╝zerindeki bellek program y├╝r├╝t├╝l├╝rken d├╝zenli olarak tahsis edilir, tahsis edilir ve yeniden boyutland─▒r─▒l─▒r ve bu par├žalanma olarak adland─▒r─▒lan bir soruna yol a├žabilir.
Par├žalanma, bellek nesnelerine aralar─▒nda ilave bellek nesneleri tutmak i├žin ├žok k├╝├ž├╝k olan k├╝├ž├╝k bo┼čluklar tahsis edildi─činde meydana gelir.
Net sonu├ž, daha fazla bellek ay─▒rmas─▒ i├žin kullan─▒lamayan y─▒─č─▒n alan─▒n─▒n bir y├╝zdesidir.

─░kisi birlikte

├çok i┼č par├žac─▒kl─▒ bir uygulamada, her i┼č par├žac─▒─č─▒n─▒n kendi y─▒─č─▒n─▒na sahip olacakt─▒r. Ancak, t├╝m farkl─▒ i┼č par├žac─▒klar─▒ y─▒─č─▒n─▒ payla┼čacak.
Farkl─▒ i┼č par├žac─▒─č─▒ y─▒─č─▒n─▒ ├žok par├žac─▒kl─▒ bir uygulamada payla┼čt─▒─č─▒ i├žin, bu ayn─▒ zamanda, i┼č par├žac─▒─č─▒ i├žindeki ayn─▒ bellek par├žalar─▒na eri┼čmeye ve bunlar─▒ i┼člemeye ├žal─▒┼čmazlar, b├Âylece i┼č par├žac─▒─č─▒ aras─▒nda bir miktar koordinasyon olmas─▒ gerekti─či anlam─▒na gelir. Ayn─▒ zaman.

Hangisi daha h─▒zl─▒ - y─▒─č─▒n m─▒, y─▒─č─▒n m─▒? Ve neden?

Y─▒─č─▒n y─▒─č─▒ndan ├žok daha h─▒zl─▒.
Bunun nedeni haf─▒zan─▒n y─▒─č─▒na tahsis edilme bi├žimidir.
Y─▒─č─▒na bellek tahsis etmek, y─▒─č─▒n i┼čaret├žisini yukar─▒ hareket ettirmek kadar kolayd─▒r.

Programlamaya yeni ba┼člayanlar i├žin, y─▒─č─▒n─▒ kullanmak muhtemelen daha iyi bir fikirdir.
Y─▒─č─▒n k├╝├ž├╝k oldu─čundan, verileriniz i├žin tam olarak ne kadar belle─če ihtiyac─▒n─▒z olaca─č─▒n─▒ veya verilerinizin boyutunun ├žok k├╝├ž├╝k oldu─čunu bildi─činizde kullanmak istersiniz.
Verileriniz i├žin ├žok fazla belle─če ihtiya├ž duyaca─č─▒n─▒z─▒ bildi─činizde ├Âbek kullanmak daha iyidir veya ne kadar belle─če ihtiya├ž duyaca─č─▒n─▒zdan emin de─čilsiniz (dinamik bir dizide oldu─ču gibi).

Java Bellek Modeli


Resim tan─▒m─▒n─▒ buraya girin

Y─▒─č─▒n, yerel de─či┼čkenlerin (y├Ântem parametreleri dahil) depoland─▒─č─▒ bellek alan─▒d─▒r. Nesne de─či┼čkenleri s├Âz konusu oldu─čunda, bunlar yaln─▒zca ├Âbek ├╝zerindeki ger├žek nesnelere referanslar (i┼čaret├žiler).
Bir nesnenin her ba┼člat─▒l─▒┼č─▒nda, o nesnenin verilerini (durumunu) tutmak i├žin bir y─▒─č─▒n bellek y─▒─č─▒n─▒ bir kenara konur. Nesneler ba┼čka nesneler i├žerebildi─činden, bu verilerin bir k─▒sm─▒ asl─▒nda i├ž i├že ge├žmi┼č nesnelere referanslar i├žerebilir.


108







Y─▒─č─▒nla ilgin├ž ┼čeyler yapabilirsiniz. ├ľrne─čin, alloca gibi (kullan─▒m─▒na ili┼čkin ├žok fazla uyar─▒n─▒n ├╝stesinden gelebilece─činizi varsayarsak), yani y─▒─č─▒n i├žin de─čil y─▒─č─▒n i├žin ├Âzellikle y─▒─č─▒n─▒ kullanan bir malloc ┼čekli gibi fonksiyonlara sahipsiniz.

Bununla birlikte, y─▒─č─▒n tabanl─▒ bellek hatalar─▒, ya┼čad─▒─č─▒m en k├Ât├╝ hatalardan baz─▒lar─▒. Y─▒─č─▒n bellek kullan─▒yorsan─▒z ve ayr─▒lan blo─čunuzun s─▒n─▒rlar─▒n─▒ a┼čt─▒ysan─▒z, bir par├ža hatas─▒n─▒ tetikleme ┼čans─▒n─▒z olduk├ža y├╝ksektir. (% 100 de─čil: blo─čunuz, daha ├Ânce tahsis etti─činiz bir ba┼čkas─▒yla ayn─▒ anda biti┼čik olabilir.) Ancak y─▒─č─▒nta yarat─▒lan de─či┼čkenler her zaman birbiriyle biti┼čik oldu─čundan, s─▒n─▒rlar─▒n d─▒┼č─▒nda yaz─▒lmas─▒ ba┼čka bir de─či┼čkenin de─čerini de─či┼čtirebilir. Program─▒m─▒n mant─▒k yasalar─▒na uymay─▒ b─▒rakt─▒─č─▒n─▒ hissetti─čimde muhtemelen ta┼čma oldu─čunu ├Â─črendim.


89







Basit├že, y─▒─č─▒n yerel de─či┼čkenlerin yarat─▒ld─▒─č─▒ yerdir. Ayr─▒ca, program sayac─▒n─▒ bir alt programa her ├ža─č─▒rd─▒─č─▒n─▒zda (bir sonraki makinenin talimat─▒na i┼čaret├ži) ve t├╝m ├Ânemli kay─▒tlar ve bazen parametreler y─▒─č─▒na itilir. Ard─▒ndan, alt rutin i├žindeki herhangi bir yerel de─či┼čken y─▒─č─▒n─▒n ├╝zerine itilir (ve oradan kullan─▒l─▒r). Alt yordam bitti─činde, t├╝m bunlar y─▒─č─▒ndan geri f─▒rlar. PC ve kay─▒t verileri, al─▒p geldi─či yere geri koyulur, b├Âylece program─▒n─▒z mutlu bir ┼čekilde devam eder.

├ľbek, bellek dinamik bellek tahsislerinden olu┼čur (a├ž─▒k "yeni" veya "tahsis" ├ža─čr─▒lar─▒). Farkl─▒ boyutlardaki haf─▒za bloklar─▒n─▒ ve tahsisat durumlar─▒n─▒ takip edebilen ├Âzel bir veri yap─▒s─▒d─▒r.

"Klasik" sistemlerde RAM, y─▒─č─▒n i┼čaret├žisinin haf─▒zan─▒n alt─▒ndan ba┼člamas─▒na, y─▒─č─▒n i┼čaret├žisinin tepeden ba┼člamas─▒na ve birbirlerine do─čru b├╝y├╝melerine olanak sa─člad─▒. ├çak─▒┼č─▒rlarsa, RAM'iniz biter. Yine de, modern ├žoklu i┼č par├žac─▒kl─▒ i┼čletim sistemlerinde ├žal─▒┼čmaz. Her i┼č par├žac─▒─č─▒n─▒n kendi y─▒─č─▒n─▒na sahip olmas─▒ gerekir ve bunlar dinamik olarak olu┼čturulabilir.


86







WikiAnwser'dan.

y─▒─č─▒n

Bir i┼člev veya y├Ântem, s─▒rayla ba┼čka bir i┼člevi vb. ├ça─č─▒ran ba┼čka bir i┼člevi ├ža─č─▒rd─▒─č─▒nda, t├╝m bu i┼člevlerin y├╝r├╝t├╝lmesi, en son i┼člevin de─čerini d├Ând├╝rene kadar ask─▒ya al─▒n─▒r.

Bu ask─▒ya al─▒nm─▒┼č i┼člev ├ža─čr─▒lar─▒ zinciri, y─▒─č─▒n i┼člevidir, ├ž├╝nk├╝ y─▒─č─▒ndaki ├Â─čeler (i┼člev ├ža─čr─▒lar─▒) birbirine ba─čl─▒d─▒r.

─░stisna i┼čleme ve iplik y├╝r├╝tme i┼člemlerinde dikkate al─▒nmas─▒ gereken y─▒─č─▒n ├Ânemlidir.

Y─▒─č─▒n

Y─▒─č─▒n basit├že programlar taraf─▒ndan de─či┼čkenleri saklamak i├žin kullan─▒lan haf─▒zad─▒r. Y─▒─č─▒n ├Â─česinin (de─či┼čkenler) birbiriyle hi├žbir ba─č─▒ml─▒l─▒─č─▒ yoktur ve her zaman her zaman rastgele eri┼čilebilir.


80







y─▒─č─▒n

  • ├çok h─▒zl─▒ eri┼čim
  • De─či┼čkenlerin a├ž─▒k├ža ayr─▒lmas─▒ gerekmez
  • Alan CPU taraf─▒ndan verimli bir ┼čekilde y├Ânetilir, bellek par├žalanmaz
  • Sadece yerel de─či┼čkenler
  • Y─▒─č─▒n boyutunda s─▒n─▒r (i┼čletim sistemine ba─čl─▒)
  • De─či┼čkenler yeniden boyutland─▒r─▒lamaz

Y─▒─č─▒n

  • De─či┼čkenlere global olarak eri┼čilebilir
  • Bellek boyutunda limit yok
  • (Nispeten) daha yava┼č eri┼čim
  • Alan─▒n garantili ve verimli kullan─▒lmamas─▒, haf─▒za bloklar─▒ tahsis edildikten sonra haf─▒za zaman i├žinde par├žalanabilir, sonra serbest b─▒rak─▒labilir.
  • Belle─či y├Ânetmelisiniz (de─či┼čkenleri ay─▒rmak ve serbest b─▒rakmakla g├Ârevlisiniz)
  • De─či┼čkenler realloc () kullan─▒larak yeniden boyutland─▒r─▒labilir

51







Tamam, basit ve k─▒saca, s─▒ral─▒ ve s─▒ral─▒ de─čil demek istiyorlar ...!

Y─▒─č─▒n : Y─▒─č─▒n maddelerinde i┼čler ├╝st ├╝ste gelir, i┼členmeleri daha h─▒zl─▒ ve daha verimli olur!

B├Âylece, her zaman belirli bir maddeye i┼čaret edecek bir endeks vard─▒r, i┼člem daha h─▒zl─▒ olacakt─▒r, ├Â─čeler aras─▒nda da bir ili┼čki vard─▒r! ...

├ľbek : Sipari┼č yok, i┼člem yava┼člar ve de─čerler belirli bir sipari┼č veya endeks olmadan birbirine kar─▒┼č─▒r ... rastgeledir ve aralar─▒nda bir ili┼čki yoktur ... dolay─▒s─▒yla uygulama ve kullan─▒m s├╝resi de─či┼čebilir ...

Nas─▒l g├Âr├╝nd├╝klerini g├Âstermek i├žin a┼ča─č─▒daki resmi de olu┼čturuyorum:


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin


44







K─▒sacas─▒

Her ikisi de bilgisayar─▒n RAM'inde depolanan statik bellek tahsisi i├žin bir y─▒─č─▒n ve dinamik bellek tahsisi i├žin bir y─▒─č─▒n kullan─▒l─▒r.


Detayda

Y─▒─č─▒n

Y─▒─č─▒n, CPU taraf─▒ndan olduk├ža yak─▒ndan y├Ânetilen ve optimize edilen "LIFO" (ilk giren ilk ├ž─▒kar) veri yap─▒s─▒d─▒r. Bir i┼člev her yeni bir de─či┼čken bildirdi─činde, y─▒─č─▒na "itilir". Sonra bir i┼člev her ├ž─▒kt─▒─č─▒nda, o i┼čleve y─▒─č─▒n─▒n ├╝st├╝ne itilen t├╝m de─či┼čkenler serbest b─▒rak─▒l─▒r (yani silinirler). Bir y─▒─č─▒n de─či┼čkeni serbest b─▒rak─▒ld─▒─č─▒nda, bu bellek b├Âlgesi di─čer y─▒─č─▒n de─či┼čkenleri i├žin kullan─▒labilir duruma gelir.

Y─▒─č─▒n─▒ de─či┼čkenleri saklamak i├žin kullanman─▒n avantaj─▒, belle─čin sizin i├žin y├Ânetilmesidir. Belle─či elle ay─▒rman─▒z veya bir daha ihtiya├ž duymad─▒─č─▒n─▒zda bir kez serbest b─▒rakman─▒z gerekmez. Dahas─▒, CPU y─▒─č─▒n belle─či ├žok verimli bir ┼čekilde organize etti─činden, y─▒─č─▒n de─či┼čkenlerinden okuma ve yazma ├žok h─▒zl─▒d─▒r.

Daha fazlas─▒ burada bulunabilir .


Y─▒─č─▒n

├ľbek, bilgisayar─▒n─▒z─▒n belle─činin sizin i├žin otomatik olarak y├Ânetilmeyen ve CPU taraf─▒ndan s─▒k─▒ ┼čekilde y├Ânetilmeyen bir b├Âlgesidir. Daha serbest y├╝zen bir bellek b├Âlgesidir (ve daha b├╝y├╝kt├╝r). ├ľbek ├╝zerinde bellek ay─▒rmak i├žin, yerle┼čik C i┼člevlerine sahip olan malloc () veya calloc () kullanman─▒z gerekir. ├ľbek ├╝zerinde bellek tahsis ettikten sonra, art─▒k gerekmedi─činde bu belle─či ├ž─▒karmak i├žin free () kullanmaktan sorumlusunuz.

Bunu yapmazsan─▒z, program─▒n─▒z bellek s─▒z─▒nt─▒s─▒ olarak bilinen ┼čeye sahip olacakt─▒r. Yani, ├Âbek ├╝zerindeki bellek hala bir kenara b─▒rak─▒lacak (ve di─čer i┼člemler i├žin uygun olmayacak). Hata ay─▒klama b├Âl├╝m├╝nde g├Ârece─čimiz gibi, bellek s─▒z─▒nt─▒lar─▒n─▒ tespit etmenize yard─▒mc─▒ olacak Valgrind ad─▒nda bir ara├ž var .

Y─▒─č─▒n─▒n aksine, ├Âbek de─či┼čken boyutta boyut s─▒n─▒rlamalar─▒na sahip de─čildir (bilgisayar─▒n─▒z─▒n belirgin fiziksel s─▒n─▒rlamalar─▒ d─▒┼č─▒nda). Y─▒─č─▒n haf─▒zas─▒nda okunmas─▒ ve yaz─▒lmas─▒ biraz daha yava┼čt─▒r, ├ž├╝nk├╝ bir ki┼činin y─▒─č─▒ntaki belle─če eri┼čmek i├žin i┼čaret├žiler kullanmas─▒ gerekir. ─░┼čaret├žiler hakk─▒nda k─▒saca konu┼čaca─č─▒z.

Y─▒─č─▒n─▒n aksine, ├Âbek ├╝zerinde yarat─▒lan de─či┼čkenlere, program─▒n─▒z─▒n herhangi bir yerinde, herhangi bir i┼člev taraf─▒ndan eri┼čilebilir. Y─▒─č─▒n de─či┼čkenleri asl─▒nda kapsamda globaldir.

Daha fazlas─▒ burada bulunabilir .


Y─▒─č─▒nda tahsis edilen de─či┼čkenler do─črudan belle─če kaydedilir ve bu belle─če eri┼čim ├žok h─▒zl─▒d─▒r ve tahsisi program derlendi─činde ele al─▒n─▒r. Bir i┼člev veya y├Ântem, s─▒rayla ba┼čka bir i┼člevi vb. ├ça─č─▒ran ba┼čka bir i┼člevi ├ža─č─▒rd─▒─č─▒nda, t├╝m bu i┼člevlerin y├╝r├╝t├╝lmesi, en son i┼člevin de─čerini d├Ând├╝rene kadar ask─▒ya al─▒n─▒r. Y─▒─č─▒n her zaman bir LIFO s─▒ras─▒na ayr─▒lm─▒┼čt─▒r, en son ayr─▒lan blok her zaman serbest b─▒rak─▒lacak bir sonraki bloktur. Bu, y─▒─č─▒n─▒ takip etmeyi ger├žekten kolayla┼čt─▒r─▒r, bir blo─ču y─▒─č─▒ndan serbest b─▒rakmak, bir i┼čaret├žiyi ayarlamaktan ba┼čka bir ┼čey de─čildir.

├ľbek ├╝zerinde ayr─▒lan de─či┼čkenlerin ├žal─▒┼čma zaman─▒nda tahsis edilmi┼č bellekleri vard─▒r ve bu belle─če eri┼čim biraz daha yava┼čt─▒r, ancak ├Âbek boyutu yaln─▒zca sanal belle─čin boyutu ile s─▒n─▒rl─▒d─▒r. Y─▒─č─▒n ├Â─čelerinin birbirleriyle hi├žbir ba─č─▒ml─▒l─▒─č─▒ yoktur ve her zaman herhangi bir zamanda rastgele eri┼čilebilir. Bir blo─ču istedi─činiz zaman tahsis edebilir ve istedi─činiz zaman bo┼čaltabilirsiniz. Bu, herhangi bir zamanda y─▒─č─▒n─▒n hangi b├Âl├╝mlerinin tahsis edildi─čini veya serbest b─▒rak─▒ld─▒─č─▒n─▒ takip etmeyi ├žok daha karma┼č─▒k hale getirir.


Resim tan─▒m─▒n─▒ buraya girin

Derleme s├╝resinden ├Ânce ne kadar veri ay─▒rman─▒z gerekti─čini tam olarak biliyorsan─▒z y─▒─č─▒n─▒ kullanabilirsiniz. ├çok b├╝y├╝k de─čil. ├çal─▒┼čma zaman─▒nda tam olarak ne kadar veriye ihtiya├ž duyaca─č─▒n─▒z─▒ bilmiyorsan─▒z veya ├žok fazla veri ay─▒rman─▒z gerekirse, y─▒─č─▒n─▒ kullanabilirsiniz.

├çok i┼č par├žac─▒kl─▒ bir durumda, her i┼č par├žac─▒─č─▒ kendi tamamen ba─č─▒ms─▒z y─▒─č─▒na sahip olacak, ancak y─▒─č─▒n─▒ payla┼čacaklar. Y─▒─č─▒n i┼č par├žac─▒─č─▒na ├Âzg├╝ ve y─▒─č─▒n uygulamaya ├Âzg├╝d├╝r. ─░stisna i┼čleme ve iplik y├╝r├╝tme i┼člemlerinde dikkate al─▒nmas─▒ gereken y─▒─č─▒n ├Ânemlidir.

Her i┼č par├žac─▒─č─▒ bir y─▒─č─▒n al─▒r, ancak uygulama i├žin genellikle yaln─▒zca bir y─▒─č─▒n vard─▒r (farkl─▒ ay─▒rma t├╝rleri i├žin birden fazla y─▒─č─▒n olmas─▒ nadir de─čildir).


Resim tan─▒m─▒n─▒ buraya girin

├çal─▒┼čma zaman─▒nda, uygulama daha fazla y─▒─č─▒n gerektiriyorsa, bo┼č bellekten bellek ay─▒rabilir ve y─▒─č─▒n belle─če ihtiya├ž duyuyorsa, uygulama i├žin bo┼č bellekten ayr─▒lm─▒┼č bellek belle─či ay─▒rabilir.

Hatta burada ve burada daha fazla ayr─▒nt─▒ verilmektedir .


┼×imdi sorunuzun cevaplar─▒na gelin .

─░┼čletim sistemi veya dil ├žal─▒┼čma zaman─▒ ne ├Âl├ž├╝de kontrol edilir?

─░┼čletim sistemi, i┼č par├žac─▒─č─▒ olu┼čturuldu─čunda her sistem d├╝zeyinde i┼č par├žac─▒─č─▒ i├žin y─▒─č─▒n─▒ ay─▒r─▒r. Genellikle i┼čletim sistemi, dilimi ├žal─▒┼čma zaman─▒ taraf─▒ndan uygulamaya y─▒─č─▒n ay─▒rmak i├žin ├ža─čr─▒l─▒r.

Daha fazlas─▒ burada bulunabilir .

Kapsam─▒ nedir?

Zaten ├╝stte verildi.

"Derleme s├╝resinden ├Ânce ne kadar veri ay─▒rman─▒z gerekti─čini tam olarak biliyorsan─▒z y─▒─č─▒n─▒ kullanabilirsiniz, ├žok b├╝y├╝k de─čil. E─čer ├žal─▒┼čma zaman─▒nda tam olarak ne kadar veriye ihtiyac─▒n─▒z olaca─č─▒n─▒ bilmiyorsan─▒z y─▒─č─▒n─▒ kullanabilirsiniz. ├çok fazla veri ay─▒rman─▒z gerekiyor. "

Daha fazlas─▒ burada bulunabilir .

Her birinin boyutunu ne belirler?

Bir i┼č par├žac─▒─č─▒ olu┼čturuldu─čunda y─▒─č─▒n─▒n─▒n boyutu OS taraf─▒ndan ayarlan─▒r . Y─▒─č─▒n boyutu uygulama ba┼člang─▒c─▒nda belirlenir, ancak alan gerekti─činde b├╝y├╝yebilir (tahsisat├ž─▒ i┼čletim sisteminden daha fazla bellek ister).

Birini daha h─▒zl─▒ yapan nedir?

Y─▒─č─▒n tahsisi ├žok daha h─▒zl─▒d─▒r ├ž├╝nk├╝ tek yapt─▒─č─▒ y─▒─č─▒n g├Âstergesini hareket ettirmektir. Bellek havuzlar─▒n─▒ kullanarak, y─▒─č─▒n tahsisinde kar┼č─▒la┼čt─▒r─▒labilir performans elde edebilirsiniz, ancak bu biraz ek bir karma┼č─▒kl─▒k ve kendi ba┼č a─čr─▒lar─▒yla birlikte gelir.

Ayr─▒ca y─▒─č─▒n-y─▒─č─▒n y─▒─č─▒n─▒ sadece bir performans de─čerlendirmesi de─čildir; Ayn─▒ zamanda nesnelerin beklenen ├Âmr├╝ hakk─▒nda size ├žok ┼čey anlat─▒r.

Detaylar bulunabilir burada .


43







1980'lerde, UNIX b├╝y├╝k ┼čirketleri kendi ┼čirketlerine deviren tav┼čanlar gibi yay─▒ld─▒. Exxon'un tarihte kaybetti─či onlarca marka ismi vard─▒. Haf─▒zan─▒n nas─▒l yerle┼čtirildi─či bir├žok uygulay─▒c─▒n─▒n takdirine kalm─▒┼čt─▒r.

Tipik bir C program─▒, bellekte, brk () de─čerini de─či┼čtirerek art─▒rma imkan─▒yla d├╝z bir ┼čekilde d├╝zenlenmi┼čtir. Tipik olarak, HEAP bu brk de─čerinin hemen alt─▒ndayd─▒ ve brk art─▒┼č─▒ mevcut y─▒─č─▒n miktar─▒n─▒ artt─▒rd─▒.

Tek STACK tipik olarak bir sonraki sabit bellek blo─čunun tepesine kadar de─čerli hi├žbir ┼čey i├žermeyen bir bellek yolu olan HEAP'─▒n alt─▒ndaki bir aland─▒. Bu bir sonraki blok, d├Âneminin ├╝nl├╝ bilgisayar korsanlar─▒ndan birinde y─▒─č─▒n verilerinin ├╝zerine yaz─▒labilecek ├žo─ču kez KOD'du.

Bir tipik bellek blo─ču, bir ├╝reticinin teklifinde yanl─▒┼čl─▒kla s─▒f─▒rlanmayan BSS (s─▒f─▒r de─čer blo─ču) idi. Bir dize, dizeleri ve say─▒lar─▒ i├žeren ba┼člang─▒├ž ÔÇőÔÇőde─čerleri i├žeren DATA idi. ├ť├ž├╝nc├╝s├╝, CRT (C ├žal─▒┼čma zaman─▒), main, fonksiyonlar ve k├╝t├╝phaneler i├žeren CODE idi.

UNIX'te sanal belle─čin ortaya ├ž─▒k─▒┼č─▒, k─▒s─▒tlamalar─▒n ├žo─čunu de─či┼čtirir. Bu bloklar─▒n biti┼čik olmas─▒, sabitlenmesi ya da belirli bir ┼čekilde sipari┼č edilmesi i├žin hi├žbir neden yoktur. Tabii ki, UNIX'ten ├Ânce bu k─▒s─▒tlamalardan muzdarip olmayan bir Multics vard─▒. ─░┼čte o d├Ânemin haf─▒za d├╝zenlerinden birini g├Âsteren ┼čematik.


Tipik bir 1980'lerin tarz─▒ UNIX C program─▒ bellek d├╝zeni


35







sanal bellekteki her i┼člemin y─▒─č─▒n─▒ , y─▒─č─▒n─▒ ve verileri :


y─▒─č─▒n, y─▒─č─▒n ve statik veri


32







Birka├ž sent: San─▒r─▒m haf─▒zay─▒ grafiksel ve daha basit ├žizmek iyi olacak:


Bu, daha kolay anla┼č─▒lmas─▒ i├žin sadele┼čtirilmi┼č i┼člem bellek yap─▒m vizyonumdur.


Oklar - Y─▒─č─▒n ve y─▒─č─▒n─▒n nerede b├╝y├╝d├╝─č├╝n├╝, i┼člem y─▒─č─▒n─▒ boyutunun OS'de tan─▒mlanm─▒┼č s─▒n─▒r─▒n─▒ g├Âsterir, i┼č par├žac─▒─č─▒ y─▒─č─▒n boyutu s─▒n─▒rlar─▒n─▒ i┼č par├žac─▒─č─▒ndaki parametrelere g├Âre genellikle API olu┼čturur. Y─▒─č─▒n genellikle i┼člem maksimum sanal bellek boyutuyla s─▒n─▒rlan─▒r, ├Ârne─čin 32 bit 2-4 GB.

├çok basit bir y├Ântem: i┼člem y─▒─č─▒n─▒, malloc () gibi bir ┼čey ile ortak durumda bellek tahsisi i├žin kullanarak, i┼člem ve i├žindeki t├╝m i┼č par├žac─▒klar─▒ i├žin geneldir .

Y─▒─č─▒n, genel durum i┼člevi geri d├Ân├╝┼č i┼čaret├žilerinde ve de─či┼čkenlerde, i┼člev ├ža─čr─▒s─▒nda parametre olarak i┼členen yerel i┼člev de─či┼čkenlerinde saklamak i├žin h─▒zl─▒ bellektir.


24







Baz─▒ cevaplar nitpicking gitti─či i├žin, akar─▒ma katk─▒da bulunaca─č─▒m.

┼×a┼č─▒rt─▒c─▒ bir ┼čekilde hi├ž kimse, ├žoklu (yani ├žal─▒┼čan i┼čletim sistemi seviyesindeki konu say─▒s─▒yla ilgili de─čil) ├ža─čr─▒ y─▒─č─▒nlar─▒n─▒n yaln─▒zca egzotik dillerde (PostScript) veya platformlarda (Intel Itanium) de─čil, liflerde , ye┼čil liflerde de bulunaca─č─▒ndan bahsetmedi. ve baz─▒ coroutinler uygulamalar─▒ .

Lifler, ye┼čil iplikler ve koroinler benzer ┼čekilde, bu da kafa kar─▒┼č─▒kl─▒─č─▒na neden olur. Lifler ve ye┼čil iplikler aras─▒ndaki fark, eskiden kooperatif ├žoklu g├Ârev kullanmas─▒d─▒r, ikincisi ise kooperatif veya ├Ânleyici birini (veya hatta her ikisini de) i├žerebilir. Lifler ve koroutinler aras─▒ndaki ayr─▒m i├žin, buraya bak─▒n .

Her durumda, hem fiberlerin, hem ye┼čil ipliklerin hem de coroutinlerin amac─▒ ayn─▒ anda ├žal─▒┼čan ├žoklu fonksiyonlara sahip olmakla birlikte , kontrolleri birbirlerinden ileri ve geri aktaracak ┼čekilde tek bir i┼čletim sistemi d├╝zeyinde iplik i├žinde paralel olarak de─čil ( bu SO i├žin farkl─▒ olan soruya bak─▒n─▒z ) organize bir ┼čekilde.

Fiber, ye┼čil iplik veya koroinler kullan─▒rken, genellikle i┼člev ba┼č─▒na ayr─▒ bir y─▒─č─▒na sahip olursunuz . (Teknik olarak, yaln─▒zca bir y─▒─č─▒n de─čil t├╝m y├╝r├╝tme ba─člam─▒ i┼člev ba┼č─▒nad─▒r. En ├Ânemlisi, CPU kaydeder.) Her i┼č par├žac─▒─č─▒ i├žin, ayn─▒ anda ├žal─▒┼čan i┼člevlerin oldu─ču kadar ├žok y─▒─č─▒n vard─▒r ve i┼č par├žac─▒─č─▒ her i┼člevin y├╝r├╝t├╝lmesi aras─▒nda ge├ži┼č yapar program─▒n─▒z─▒n mant─▒─č─▒na g├Âre. Bir i┼člev sona erdi─činde, y─▒─č─▒n─▒ yok edilir. Bu nedenle, y─▒─č─▒nlar─▒n say─▒s─▒ ve ├Âm├╝rleri dinamiktir ve i┼čletim sistemi seviyesindeki iplik say─▒s─▒na g├Âre belirlenmez!

" Genellikle i┼člev ba┼č─▒na ayr─▒ bir y─▒─č─▒na sahip " dedi─čime dikkat edin . Her iki Orada konum stackful ve stackless couroutines ait uygulamalar. En dikkat ├žekici y─▒─č─▒n C ++ uygulamalar─▒ Boost.Coroutine ve Microsoft PPL 'dir async/await . (Bununla birlikte, C ++ 'n─▒n C ++ 17'ye ├Ânerilen devam ettirilebilir i┼člevleri (aka " async ve await "), y─▒─č─▒ns─▒z koroutinler kullanmas─▒ muhtemeldir.)

Lifler, C ++ standart k├╝t├╝phanesine ├Âneridir. Ayr─▒ca, baz─▒ ├╝├ž├╝nc├╝ taraf k├╝t├╝phaneleri var . Ye┼čil ipler Python ve Ruby gibi dillerde olduk├ža pop├╝lerdir.


21







├ľnemli noktalar zaten kapsanm─▒┼č olsa da payla┼čacak bir ┼čeyim var.

y─▒─č─▒n

  • ├çok h─▒zl─▒ eri┼čim.
  • RAM'de saklan─▒r.
  • ─░┼člev ├ža─čr─▒lar─▒ buraya yerel de─či┼čkenler ve iletilen i┼člev parametreleriyle birlikte y├╝klenir.
  • Program kapsam d─▒┼č─▒ kald─▒─č─▒nda alan otomatik olarak serbest b─▒rak─▒l─▒r.
  • S─▒ral─▒ haf─▒zaya kaydedilir.

Y─▒─č─▒n

  • Stack ile kar┼č─▒la┼čt─▒rmal─▒ olarak yava┼č eri┼čim.
  • RAM'de saklan─▒r.
  • Dinamik olarak yarat─▒lm─▒┼č de─či┼čkenler burada saklan─▒r, bu i┼člem daha sonra kullan─▒mdan sonra ayr─▒lan haf─▒zan─▒n bo┼čalt─▒lmas─▒n─▒ gerektirir.
  • Her zaman i┼čaret├ži taraf─▒ndan eri┼čilen, haf─▒za ay─▒rma yap─▒lan her yerde saklan─▒r.

─░lgin├ž not:

  • ─░┼člev ├ža─čr─▒lar─▒ y─▒─č─▒nda saklanm─▒┼č olsayd─▒, 2 da─č─▒n─▒k noktaya yol a├žard─▒:
    1. Y─▒─č─▒ndaki s─▒ral─▒ depolama nedeniyle y├╝r├╝tme daha h─▒zl─▒d─▒r. Y─▒─č─▒n i├žinde depolama, ├žok fazla zaman harcamas─▒na ve b├Âylece t├╝m program─▒n daha yava┼č ├žal─▒┼čmas─▒na neden olur.
    2. ─░┼člevler y─▒─č─▒n i├žinde saklan─▒rsa (i┼čaret├ži taraf─▒ndan g├Âsterilen kar─▒┼č─▒k depolama), arayan adrese geri d├Ânmenin (haf─▒zada s─▒ral─▒ saklama nedeniyle ortaya ├ž─▒kan y─▒─č─▒n) geri d├Ân├╝┼č├╝ olmazd─▒.

15







Vaov! Pek ├žok cevap ve onlardan birinin do─čru anlad─▒─č─▒n─▒ sanm─▒yorum ...

1) Nerede ve ne (fiziksel olarak ger├žek bir bilgisayar─▒n haf─▒zas─▒nda)?

Y─▒─č─▒n, program g├Âr├╝nt├╝n├╝ze ayr─▒lan en y├╝ksek bellek adresi olarak ba┼člayan ve ard─▒ndan oradaki de─čeri azaltan bellektir. ├ça─čr─▒lan i┼člev parametreleri ve i┼člevlerde kullan─▒lan t├╝m ge├žici de─či┼čkenler i├žin ayr─▒lm─▒┼čt─▒r.

─░ki y─▒─č─▒n var: kamu ve ├Âzel.

├ľzel ├Âbek, program─▒n─▒zdaki son kod bayt─▒ndan sonra 16 baytl─▒k bir s─▒n─▒rda (64 bit programlar i├žin) veya 8 baytl─▒k bir s─▒n─▒rda (32 bit programlar i├žin) ba┼člar ve ard─▒ndan oradaki de─čer artar. Ayr─▒ca varsay─▒lan ├Âbek olarak da adland─▒r─▒l─▒r.

├ľzel y─▒─č─▒n ├žok b├╝y├╝rse y─▒─č─▒n alan─▒ ├╝st ├╝ste biner, y─▒─č─▒n fazla b├╝y├╝rse y─▒─č─▒n ├╝st ├╝ste biner. Y─▒─č─▒n, daha y├╝ksek bir adreste ba┼člar ve d├╝┼č├╝k adrese do─čru ├žal─▒┼č─▒r, uygun kesmekle, y─▒─č─▒n─▒, ├Âzel y─▒─č─▒n alan─▒n─▒ a┼čacak ve kod alan─▒n─▒ ├╝st ├╝ste gelecek ┼čekilde o kadar b├╝y├╝k yapabilirsiniz. O zaman p├╝f noktas─▒, koda girebilece─činiz kod alan─▒ndan yeterince ├╝st ├╝ste gelmektir. Bunu yapmak biraz zor ve bir program ├ž├Âkmesi riskini g├Âze al─▒yorsunuz, ancak kolay ve ├žok etkili.

Ortak y─▒─č─▒n, program─▒n─▒z─▒n g├Âr├╝nt├╝ alan─▒ d─▒┼č─▒ndaki kendi bellek alan─▒nda bulunur. Bellek kaynaklar─▒ yetersiz kal─▒rsa, sabit diske kopyalanacak olan bu bellektir.

2) ─░┼čletim sistemi veya dil ├žal─▒┼čma zaman─▒ ne ├Âl├ž├╝de kontrol edilir?

Y─▒─č─▒n programc─▒ taraf─▒ndan denetlenir, ├Âzel ├Âbek i┼čletim sistemi taraf─▒ndan y├Ânetilir ve genel ├Âbek hi├ž kimse taraf─▒ndan denetlenmez, ├ž├╝nk├╝ bu bir i┼čletim sistemi hizmetidir - talepte bulunursunuz ya kabul edilir ya da reddedilir.

2b) Kapsamlar─▒ nedir?

Hepsi program i├žin k├╝resel, ancak i├žerikleri ├Âzel, genel veya genel olabilir.

2c) Her birinin boyutunu ne belirler?

Y─▒─č─▒n ve ├Âzel ├Âbek boyutu, derleyici ├žal─▒┼čma zaman─▒ se├ženekleriniz taraf─▒ndan belirlenir. Genel y─▒─č─▒n ├žal─▒┼čma zaman─▒nda bir size parametresi kullan─▒larak ba┼člat─▒ld─▒.

2d) Hangisini daha h─▒zl─▒ yapan nedir?

H─▒zl─▒ olacak ┼čekilde tasarlanmam─▒┼člar, faydal─▒ olacak ┼čekilde tasarlanm─▒┼člar. Programc─▒n─▒n bunlar─▒ nas─▒l kulland─▒─č─▒ ÔÇťh─▒zl─▒ÔÇŁ m─▒ yoksa ÔÇťyava┼čÔÇŁ m─▒ oldu─čunu belirler

REF:

https://norasandler.com/2019/02/18/Write-a-Compiler-10.html

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-getprocessheap

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-heapcreate


12


2019-02-20





Bir ├žok cevap kavram olarak do─črudur, ancak alt programlar─▒n ├ža─čr─▒lmas─▒na izin vermek i├žin donan─▒m taraf─▒ndan (├Ârn. Mikroi┼člemci) bir y─▒─č─▒na ihtiya├ž duyuldu─čunu not etmeliyiz (CALL .. (derleme dilinde ..). (OOP adamlar─▒ buna y├Ântem diyecek )

Y─▒─č─▒n ├╝zerinde, d├Ân├╝┼č adreslerini kaydedersiniz ve ├ža─čr─▒ Ôćĺ push / ret Ôćĺ pop do─črudan donan─▒ma g├Âre y├Ânetilir.

Parametreleri iletmek i├žin y─▒─č─▒n─▒ kullanabilirsiniz .. yazma├ž kullanmaktan daha yava┼č olsa bile (bir mikroi┼člemci gurusu ya da iyi bir 1980'lerin BIOS kitab─▒ÔÇŽ)

  • Y─▒─č─▒n olmadan hi├žbir mikroi┼člemci ├žal─▒┼čamaz. (alt program / fonksiyonlar olmadan, bir montaj dilinde bile bir program d├╝┼č├╝nemiyoruz)
  • ├ľbek olmadan yapabilirsiniz. (Bir derleme dili program─▒, y─▒─č─▒n bir i┼čletim sistemi konsepti, malloc olarak bir i┼čletim sistemi / lib ├ža─čr─▒s─▒ oldu─ču i├žin ├žal─▒┼čamaz.

Y─▒─č─▒n kullan─▒m─▒ ┼ču ┼čekilde daha h─▒zl─▒:

  • Donan─▒m ve hatta push / pop ├žok verimlidir.
  • malloc, ├žekirdek moduna girmeyi gerektirir, baz─▒ kodlar─▒ y├╝r├╝tmek i├žin kilit / semafor (veya di─čer senkronizasyon ilkellerini) kullan─▒n ve tahsisi takip etmek i├žin gereken baz─▒ yap─▒lar─▒ y├Ânetin.

8



─░lgili yay─▒nlar


Eclipse, Subclipse ve Subversive i├žin SVN eklentilerinin art─▒lar─▒ ve eksileri nelerdir? [kapal─▒]

Python i├žin hangi SOAP istemci kitapl─▒klar─▒ var ve bunlar─▒n belgeleri nerede? [kapal─▒]

Ffmpeg, libav ve avconv aras─▒ndaki farklar ve benzerlikler nelerdir?

Ek a├ž─▒klamalar Java'da nas─▒l ve nerede kullan─▒l─▒r?

Scala 2.8'de <: <, <% <ve =: = ne anlama gelir ve nerede belgelendirilir?

Fonksiyonel durumsuz bile┼čeni tepki, PureComponent, Bile┼čen; farklar nelerdir ve ne zaman kullanmal─▒y─▒z?

├ľnde gelen Java HTML ayr─▒┼čt─▒r─▒c─▒lar─▒n─▒n art─▒lar─▒ ve eksileri nelerdir? [kapal─▒]

C++ 'da uygun y─▒─č─▒n ve y─▒─č─▒n kullan─▒m─▒?

Node.js ┼čablonunda Jade ve EJS'nin art─▒lar─▒ ve eksileri nelerdir? [kapal─▒]

Statik y├Ântemler ve statik de─či┼čkenler Java'da nerede saklan─▒r?

Etiketle ilgili di─čer sorular [memory-management]


Yerel dosyalar─▒n ├╝zerine ÔÇťgit pullÔÇŁ u nas─▒l zorlar─▒m?

Python'un ├╝├žl├╝ bir ┼čartl─▒ operat├Âr├╝ var m─▒?

Python'da metas─▒n─▒flar nelerdir?

Bir HashMap ile yineleme [yinelenen]

Diziye bir ┼čey nas─▒l eklenir?

Git deposundaki silinmi┼č dosyay─▒ bulma ve geri y├╝kleme

JQuery i├žin ÔÇťvarÔÇŁ i┼člevi var m─▒?

Bir ├Â─čenin s─▒n─▒f─▒n─▒ JavaScript ile nas─▒l de─či┼čtirebilirim?

Bash'de string de─či┼čkenleri nas─▒l birle┼čtiririm

├ľrnek durumu kullanarak bir Android Etkinlik durumu nas─▒l kaydedilir?