Global değişkenler kötü mü? [kapalı]

C / C ++ 'da, küresel değişkenler profesörümün düşündüğü kadar kötü mü?

Global değişkenlerle ilgili sorun, her fonksiyonun bunlara erişimi olduğundan, hangi fonksiyonların bu değişkenleri gerçekten okuyup yazdığını anlamak giderek zorlaşmaktadır.

Uygulamanın nasıl çalıştığını anlamak için, küresel durumu değiştiren her işlevi dikkate almanız gerekir. Bu yapılabilir, ancak uygulama büyüdükçe neredeyse imkansız (ya da en azından tam bir zaman kaybı) noktasına zorlaşacaktır.

Global değişkenlere güvenmiyorsanız, gerektiğinde farklı işlevler arasında durum iletebilirsiniz. Bu şekilde, küresel durumu hesaba katmanıza gerek olmadığından, her bir işlevin ne yaptığını anlama şansınız daha yüksektir.

Önemli olan genel hedefi hatırlamaktır: netlik

"Global değişken yok" kuralı oradadır, çünkü çoğu zaman global değişkenler kodun anlamını daha az netleştirir.

Bununla birlikte, birçok kural gibi, insanlar kuralın ne yapmak istediğini değil, kuralı hatırlar.

Ben sadece küresel değişkenlerin kötülük önlemek için etrafında çok sayıda parametre geçirerek kod boyutunu iki katına gibi görünen programlar gördüm. Sonunda, küreselleri kullanmak programı okuyanlara daha açık hale getirecektir . Kuralsız bir şekilde kuralın sözüne bağlı kalarak, orijinal programcı kuralın niyetinde başarısız olmuştu.

Evet, küreseller genellikle kötüdür. Ama sonunda, programlayıcının amacının küresel değişkenlerin kullanımı ile daha net hale getirildiğini düşünüyorsanız, devam edin. Ancak, ilk parçanın nasıl çalıştığını anlamak için birini ikinci bir kod parçasına (globaller) erişmeye zorladığınızda otomatik olarak ortaya çıkan netlik düşüşünü unutmayın.

Profesörüm şöyle bir şey söylerdi: bunları doğru kullanırsanız global değişkenleri kullanmak iyidir. Onları doğru bir şekilde kullanmakta iyi olduğumu sanmıyorum, bu yüzden nadiren kullandım.

Global değişkenler yalnızca alternatifiniz olmadığında kullanılmalıdır. Ve evet, Singletons da buna dahil. Zamanın% 90'ı, bir parametreyi geçirme maliyetinden tasarruf etmek için global değişkenler tanıtılır. Ve sonra çoklu iş parçacığı / birim testi / bakım kodlaması gerçekleşir ve bir sorununuz vardır.

Yani evet, durumların% 90'ında küresel değişkenler kötüdür. İstisnaların üniversite yıllarınızda görülmesi olası değildir. Başımın üstünden düşünebileceğim bir istisna, kesme tabloları gibi doğal olarak küresel nesnelerle uğraşmaktır. DB bağlantısı gibi şeyler küresel görünmektedir , ancak değildir.

Global değişkenlerin programcı için yarattığı sorun, global değişkenleri kullanan çeşitli bileşenler arasında bileşenler arası bağlantı yüzeyini genişletmesidir . Bunun anlamı, küresel bir değişken kullanan bileşenlerin sayısı arttıkça, etkileşimlerin karmaşıklığının da artabileceğidir. Bu artan bağlantı genellikle değişiklik yaparken hataların sisteme enjekte edilmesini kolaylaştırır ve ayrıca arızaların teşhis edilmesini ve düzeltilmesini zorlaştırır. Bu artış bağlantısı, değişiklik yaparken mevcut seçeneklerin sayısını da azaltabilir ve değişikliklerin sonucunu belirlemek için küresel değişkeni kullanan çeşitli modüller üzerinden sık sık izlenmesi gereken değişiklikler için gerekli çabayı artırabilir.

Amacı Temel olarak küresel değişkenleri kullanmanın tersi olan kapsüllemenin , kaynağın daha kolay ve daha güvenli ve daha kolay test edilmesini sağlamak ve değiştirmek için kuplajı azaltmaktır. Global değişkenler kullanılmadığında birim testi kullanmak çok daha kolaydır .

Örneğin, çeşitli bileşenlerin durum makinesi olarak kullandığı numaralandırılmış bir gösterge olarak kullanılan basit bir küresel tamsayı değişkeniniz varsa ve daha sonra yeni bir bileşen için yeni bir durum ekleyerek bir değişiklik yaparsanız, diğer tüm öğeleri izlemelisiniz. Değişikliklerin bunları etkilemeyeceğinden emin olmak için Olası bir soruna örnek olarak switch, numaralandırma genel değişkeninin değerinicase , geçerli değerlerin her biri için çeşitli yerlerde kullanılıyorsa ve bazı switchifadelerin defaultişlenecek bir vakası yoksa küresel için beklenmedik bir değer aniden uygulama söz konusu olduğunda tanımlanmamış davranışınız var.

Öte yandan, paylaşılan bir veri alanının kullanımı, uygulama boyunca referans verilen bir dizi küresel parametreyi içermek için kullanılabilir. Bu yaklaşım genellikle küçük bellek alanlarına sahip gömülü uygulamalarda kullanılır.

Bu tür uygulamalarda global değişkenler kullanılırken, tipik olarak veri alanına yazma sorumluluğu tek bir bileşene tahsis edilir ve diğer tüm bileşenler alanı constasla olarak yazmaz, alan olarak görür ve okur. Bu yaklaşımı uygulamak gelişebilecek sorunları sınırlar.

Üzerinde çalışılması gereken küresel değişkenlerden birkaç sorun

Yapı gibi genel bir değişkenin kaynağı değiştirildiğinde, değişkeni kullanan her şeyin gerçek boyutunu ve bellek şablonunu bilmesi için onu kullanan her şey yeniden derlenmelidir.

Birden fazla bileşen genel değişkeni değiştirebilirse, genel değişkente tutarsız verilerin bulunmasıyla ilgili sorunlarla karşılaşabilirsiniz. Çok iş parçacıklı bir uygulamada, bir kerede yalnızca bir iş parçacığının genel değişkeni değiştirebilmesi ve bir iş parçacığı değişkeni değiştirdiğinde, tüm değişikliklerin tamamlanması için bir yol sağlamak için muhtemelen bir tür kilitleme veya kritik bölge eklemeniz gerekecektir. ve diğer iş parçacıkları değişkeni sorgulamadan veya değiştirmeden önce taahhütte bulunur.

Genel değişken kullanan çok iş parçacıklı bir uygulamada hata ayıklamak daha zor olabilir. Yarış koşullarına girebilirsiniz çoğaltmak zor olan kusurları oluşturabilir. Küresel bir değişken üzerinden iletişim kuran birkaç bileşenle, özellikle çok iş parçacıklı bir uygulamada, değişkeni hangi bileşenin değiştirdiğini ve değiştiğini nasıl değiştirdiğini bilmek çok zor olabilir.

Ad çakışması, global değişkenlerin kullanımı ile ilgili bir sorun olabilir. Genel değişkenle aynı ada sahip yerel bir değişken genel değişkeni gizleyebilir. C programlama dilini kullanırken de adlandırma kuralı sorunuyla karşılaşırsınız. Çözüm, sistemi aynı ilk üç harfle başlayan belirli bir alt sistem için küresel değişkenlerle alt sistemlere ayırmaktır (bu, hedef C'deki ad alanı çarpışmalarının çözümlenmesi için bkz .). C ++, ad alanları sağlar ve C ile, üyeleri çeşitli veri öğeleri ve bir dosyada statik olarak sağlanan veri ve işlevlere yalnızca veri görünürlüğü ile sağlanan, böylece yalnızca başvuruda bulunabilmeleri için sağlanan, genel olarak görünür bir yapı oluşturarak bu sorunu çözebilirsiniz. küresel olarak görülebilir yapı.

Bazı durumlarda, özgün uygulama amacı, tek bir iş parçacığının durumunu sağlayan genel değişkenlerin birkaç yinelenen iş parçacığının çalışmasına izin verecek şekilde değiştirileceği şekilde değiştirilir. Bir örnek, durum için global değişkenleri kullanan tek bir kullanıcı için tasarlanmış basit bir uygulama olabilir ve daha sonra uzak uygulamaların sanal kullanıcı gibi davranmasına izin vermek için REST arabirimi eklemek için yönetimden bir istek gelir . Böylece artık tek değişkenlerin ve uzak uygulamalardaki sanal kullanıcıların her birinin kendi, benzersiz küresel değişkenler kümesine sahip olması için genel değişkenleri ve durum bilgilerini çoğaltmak zorunda kalıyorsunuz.

C ++ namespaceve C için structTekniği Kullanma

C ++ programlama dili için namespaceyönerge, ad çakışması olasılığını azaltmada çok yardımcıdır. namespaceile birlikte classve çeşitli erişim anahtar kelimeler ( private, protectedve public) sen kapsülü değişkenleri gereken araçların çoğunu sağlarlar. Ancak C programlama dili bu yönergeyi sağlamaz. Bu yığın akışı akışı, C'deki Ad Alanları, C için bazı teknikler sağlar.

Yararlı bir teknik, structküresel görünürlüğe sahip olarak tanımlanan ve bunun içinde structmaruz kalınan çeşitli küresel değişkenlere ve işlevlere işaret eden tek bir bellek yerleşik veri alanına sahip olmaktır. Global değişkenlerin gerçek tanımlarına staticanahtar kelime kullanılarak dosya kapsamı verilir . Ardından const, hangisinin salt okunur olduğunu belirtmek için anahtar kelimeyi kullanırsanız, derleyici salt okunur erişimi zorlamanıza yardımcı olabilir.

Tekniği kullanmak, structküresel olanı da kapsayabilir, böylece küresel olan bir paket veya bileşen haline gelir. Bu tür bir bileşene sahip olarak, küresel olanı ve küreselliği kullanan işlevselliği etkileyen değişiklikleri yönetmek daha kolay hale gelir.

Bununla birlikte namespaceveya structteknik, isim çatışmalarını yönetmeye yardımcı olabilirken, küresellerin kullanımının özellikle modern çok iş parçacıklı bir uygulamada ortaya koyduğu bileşenler arası kuplajın altında yatan problemler hala mevcuttur.

Evet, ancak global değişkenleri kullanan kodda çalışmayı bırakıp global değişkenleri kullanan kodu kullanan başka bir şey yazmaya başlayıncaya kadar global değişkenlerin maliyetine maruz kalmazsınız. Ama maliyet hala orada.

Diğer bir deyişle, uzun vadeli dolaylı bir maliyettir ve bu nedenle çoğu insan bunun kötü olmadığını düşünür.

Eğer bir Yüksek Mahkeme davası sırasında kodunuzun yoğun bir incelemeye girmesi mümkünse, global değişkenlerden kaçınmak istediğinizden emin olmak istersiniz.

Bu makaleye bakın: Buggy alkol ölçer kodu kaynak incelemesinin önemini yansıtıyor

Her iki çalışma tarafından tespit edilen kod stiliyle ilgili bazı sorunlar vardı. Hakemleri ilgilendiren stilistik konulardan biri, korunmasız küresel değişkenlerin yaygın kullanımıydı . Bu zayıf form olarak kabul edilir, çünkü program durumunun tutarsız hale gelmesi veya değerlerin yanlışlıkla değiştirilmesi veya üzerine yazılması riskini arttırır. Araştırmacılar ayrıca, ondalık hassasiyetin kod boyunca tutarlı bir şekilde sürdürülmemesiyle ilgili bazı endişeleri de dile getirdiler.

Dostum, bahse girerim bu geliştiriciler küresel değişkenler kullanmamalarını istiyorlar!

Global değişkenler sizin yaptığınız kadar kötü, daha az değil.

Tamamen kapsüllenmiş bir program oluşturuyorsanız, globalleri kullanabilirsiniz. Globalleri kullanmak bir "günah" ama programlama günahları büyük ölçüde felsefi.

L.in.oleum'u kontrol ederseniz , değişkenleri yalnızca global olan bir dil göreceksiniz. Bu ölçeklenemez çünkü kütüphanelerin hepsinin globalleri kullanmaktan başka seçeneği yoktur.

Bununla birlikte, eğer seçenekleriniz varsa ve programcı felsefesini görmezden gelebilirseniz, küreseller o kadar da kötü değildir.

Eğer doğru kullanırsanız, Gotos da değildir.

Büyük "kötü" sorun, onları yanlış kullanırsanız, insanlar çığlık atıyor, mars lander çöküyor ve dünya patladı .... ya da böyle bir şey.

Bu soruya başka bir soru ile cevap verirdim: Singelton kullanıyor musunuz / Singeltons kötü mü?

Çünkü (neredeyse tamamı) singelton kullanımı yüceltilmiş bir küresel değişkendir.

Sorun kötü olduklarından daha az, tehlikeli olduklarından daha fazla . Kendi artıları ve eksileri var ve belirli bir görevi başarmanın en verimli veya tek yolu oldukları durumlar var. Ancak, bunları her zaman doğru şekilde kullanmak için adımlar atsanız bile yanlış kullanımları çok kolaydır.

Birkaç artı:

• Herhangi bir işlevden erişilebilir.
• Birden çok iş parçacığından erişilebilir.
• Program bitene kadar kapsam dışı kalmayacak.

Birkaç eksileri:

• Herhangi bir işlevden, parametre olarak açıkça sürüklenmeye ve / veya belgelenmeye gerek kalmadan erişilebilir.
• İplik güvenli değildir.
• Küresel ad alanını kirletir ve bunu önlemek için önlemler alınmadıkça potansiyel olarak ad çakışmalarına neden olur.

Unutmayın, listelediğim ilk iki artı ve ilk iki eksiler, sadece farklı ifadelerle aynı şeydir. Bunun nedeni, küresel bir değişkenin özelliklerinin gerçekten yararlı olabilmesidir, ancak onları faydalı kılan özellikler, tüm sorunlarının kaynağıdır.

Bazı sorunlara birkaç potansiyel çözüm:

• Sorun için gerçekten en iyi ya da en etkili çözüm olup olmadığını düşünün. Varsa herhangi daha iyi çözümler, bunun yerine kullanın.
• (İyi bir örnek olacağını benzersiz bir adla bir ad [C ++] veya tekil yapı [C, C ++] koyun Globalsya GlobalVars) ya gibi (küresel değişkenler için bir standart adlandırma kuralını kullanın global_[name]veya g_module_varNameStyle(yorumlarda underscore_d tarafından belirtildiği gibi )). Bu, hem kullanımlarını belgeleyecektir (ad alanını / yapı adını arayarak genel değişkenleri kullanan kodu bulabilirsiniz) ve genel ad alanı üzerindeki etkiyi en aza indirebilirsiniz.
• Genel değişkenlere erişen herhangi bir işlev için, hangi değişkenleri okuduğunu ve hangi değişkenleri yazdığını açıkça belgeleyin. Bu sorun gidermeyi kolaylaştıracaktır.
• Bunları kendi kaynak dosyalarına koyun externve ilişkili başlıkta bildirin, böylece kullanımları bunlara erişmesi gereken derleme birimleriyle sınırlandırılabilir. Kodunuz çok sayıda global değişkene dayanıyorsa, ancak her bir derleme biriminin yalnızca bir avuç dolusu erişime ihtiyacı varsa, bunları birden çok kaynak dosyaya ayırmayı düşünebilirsiniz, bu nedenle her dosyanın global değişkenlere erişimini sınırlamak daha kolaydır.
• Kilitlemek ve kilidini açmak için bir mekanizma kurun ve / veya kodunuzu mümkün olduğunca az fonksiyonun küresel değişkenleri gerçekten değiştirmesi gerekecek şekilde tasarlayın . İş parçacığı yarışları yine de çok iş parçacıklı programlarda sorunlara neden olsa da, bunları okumak onları yazmaktan çok daha güvenlidir.
• Temel olarak, onlara erişimi en aza indirin ve ad benzersizliğini en üst düzeye çıkarın. Ad çakışmalarından kaçınmak ve herhangi bir değişkeni potansiyel olarak değiştirebilecek kadar az işleve sahip olmak istiyorsunuz.

İyi ya da kötü olmaları onları nasıl kullandığınıza bağlıdır. Çoğunluk onları kötü kullanma eğilimindedir, bu nedenle onlara karşı genel savaşçılık. Düzgün kullanılırsa, büyük bir nimet olabilirler; kötü kullanılırsa, ancak, ve olabilir olacak size ısırmaya geri geldiğimde ve hiç beklemediğiniz nasıl.

Buna bakmanın iyi bir yolu, kendilerinin kötü olmamalarıdır, ancak kötü tasarımı etkinleştirir ve kötü tasarımın etkilerini katlanarak çoğaltabilirler.

Bunları kullanmak istemeseniz bile, bunları nasıl güvenli bir şekilde kullanacağınızı bilmediğinizden, bunları nasıl kullanacağınızı bilmek ve kullanmamayı seçmek daha iyidir. Kendinizi global değişkenlere dayanan önceden var olan kodu korumanız gereken bir durumda bulursanız, bunları nasıl doğru kullanacağınızı bilmiyorsanız zorluk yaşayabilirsiniz.

Birisinin başka bir iş parçacığında söylediği gibi (başka kelimelerle yazıyorum) "Bunu yapmanın sonuçlarını tam olarak anlayana kadar bunun gibi kurallar çiğnenmemelidir."

Global değişkenlerin gerekli olduğu veya en azından çok yararlı olduğu zamanlar vardır (Örneğin sistem tanımlı geri aramalarla çalışma). Öte yandan, size söylenen tüm nedenlerden dolayı da çok tehlikelidirler.

Programlamanın muhtemelen uzmanlara bırakılması gereken birçok yönü vardır. Bazen çok keskin bir bıçağa İHTİYACINIZ VAR. Ama hazır olana kadar birini kullanamazsın ...

Genel değişkenler genellikle kötüdür, özellikle de diğer insanlar aynı kod üzerinde çalışıyorsa ve değişkenin başvurduğu tüm yerleri aramak için 20 dakika harcamak istemiyorsa. Ve değişkenleri değiştiren iş parçacıkları eklemek yepyeni bir baş ağrısı seviyesi getirir.

Tek bir çeviri biriminde kullanılan anonim bir ad alanındaki global sabitler, profesyonel uygulamalarda ve kitaplıklarda iyi ve her yerde bulunur. Ancak veriler değiştirilebilir ve / veya birden fazla TU arasında paylaşılması gerekiyorsa, onu kapsüllemek isteyebilirsiniz - eğer tasarım uğruna değilse, kodunuzda hata ayıklayan veya çalışan herkes uğruna.

Küresel değişkenleri kullanmak, bir halının altındaki kiri süpürmeye benzer. Hızlı bir düzeltme ve kısa vadede temizlemek için bir toz tava veya vakum almaktan çok daha kolay. Ancak, daha sonra halıyı hareket ettirirseniz, altında büyük bir sürpriz yaşayacaksınız.

Bir programın yalnızca yerel olarak değiştirilmesi gereken yönlerini değiştirmenize izin veriyorsa, genel değişkenler kötüdür. OOP'de küreseller genellikle kapsülleme fikriyle çatışır.

Bence profesörünüz kötü bir alışkanlığı daha başlamadan durdurmaya çalışıyor.

Küresel değişkenlerin yeri vardır ve birçok insanın söylediği gibi bunları nerede ve ne zaman kullanacağını bilmek karmaşık olabilir. Bence profesörünüzün neden, nasıl, ne zaman ve nerede küresel değişkenlerin yasaklamaya karar verdiğinin cesur cesaretine girmek yerine. Kim bilir, gelecekte onları yasaklayabilir.

Kesinlikle hayır. Ama onları kötüye kullanmak ... bu kötü.

Akılsızca onları uğruna kaldırmak sadece ... akılsız. Avantajları ve dezavantajları bilmediğiniz sürece, açık bir şekilde yönlendirmek ve öğretildiği / öğrenildiği gibi yapmak en iyisidir, ancak küresel değişkenlerle örtülü olarak yanlış bir şey yoktur. Artıları ve eksileri anladığınızda kendi kararınızı daha iyi verin.

Küresel değişkenler küçük programlarda iyidir, ancak büyük programlarda aynı şekilde kullanılırsa korkunçtur.

Bu, öğrenirken bunları kullanma alışkanlığına kolayca sahip olabileceğiniz anlamına gelir. Profesörünüz sizi korumaya çalışıyor.

Daha deneyimli olduğunuzda, iyi olduklarını öğrenmek daha kolay olacaktır.

Hayır, hiç de fena değiller. Bu belirlemeyi yapmak için derleyici tarafından üretilen (makine) koduna bakmanız gerekir, bazen bir yerel kullanmak bir küreselden çok daha kötüdür. Ayrıca, yerel değişkene "statik" koymanın onu temelde küresel hale getirdiğini (ve gerçek bir globalin çözeceği diğer çirkin problemleri yarattığını) unutmayın. "yerel küreseller" özellikle kötüdür.

Globaller, bellek kullanımınız üzerinde de temiz kontrol sağlar, yerel halkla yapmak çok daha zor bir şeydir. Günümüzde sadece belleğin oldukça sınırlı olduğu gömülü ortamlarda önemlidir. Gömülü yazılımın diğer ortamlarla aynı olduğunu ve programlama kurallarının kartta aynı olduğunu varsaymadan önce bilmeniz gereken bir şey.

Öğretilen kuralları sorgulamanız iyi, çoğu size anlatılan nedenlerden değil. Bununla birlikte en önemli ders, bunun sonsuza dek sizinle birlikte taşınacak bir kural olmadığı, ancak bu sınıfı geçmek ve ilerlemek için onurlandırmak için gerekli bir kuraldır. Hayatta XYZ şirketi için maaş almaya devam etmek için sonunda onurlandırmanız gereken başka programlama kurallarına sahip olacağını göreceksiniz. Her iki durumda da kuralı tartışabilirsiniz, ancak bence bir işte okuldan çok daha iyi şansınız olacak. Siz birçok öğrenciden sadece birisiniz, koltuğunuz yakında değiştirilecek, profesörler alışkanlık kazanmayacak, bir işte bu ürünü sonuna kadar görmek zorunda olan küçük bir oyuncu takımından birisiniz ve bu ortamda geliştirilen kurallar ekip üyelerinin yanı sıra ürün ve şirketin faydası, herkes düşünüyorsa veya belirli bir ürün için kolejde öğrendiğiniz bir şeyi veya genel programlama hakkında bir kitabı ihlal etmek için iyi bir mühendislik sebebi varsa, fikrinizi ekibe satın ve tercih edilen yöntem değilse geçerli olarak yazın . Her şey gerçek dünyada adil bir oyundur.

Okulda veya kitaplarda size öğretilen tüm programlama kurallarına uyursanız, programlama kariyeriniz son derece sınırlı olacaktır. Muhtemelen hayatta kalabilir ve verimli bir kariyere sahip olabilirsiniz, ancak kullanabileceğiniz ortamların genişliği ve genişliği son derece sınırlı olacaktır. Kuralın nasıl ve neden orada olduğunu ve onu savunabileceğini biliyorsanız, bu iyi, eğer tek sebep "öğretmenim öyle dedi" ise, o kadar iyi değil.

Bunun gibi konuların genellikle işyerinde tartışıldığını ve derleyiciler ve işlemciler (ve diller) geliştikçe, bu tür kuralları geliştirdiklerini ve pozisyonunuzu savunmadan ve muhtemelen başka bir fikre sahip olmadığınız bir kişi tarafından bir ders verildiğini unutmayın. ileri git.

Bu arada, o zaman en yüksek sesle konuşan veya en büyük sopayı taşıyan her şeyi yapın (en yüksek sopayı veren ve en büyük sopayı taşıyan siz oluncaya kadar).

Ben çok iş parçacığı daha zor veya imkansız kılan bu iş parçacığı boyunca yapılan noktaya karşı tartışmak istiyorum. Küresel değişkenler paylaşılan durumdur, ancak küresellere alternatifler (örneğin etrafta işaretçiler geçmek) durumu da paylaşabilir. Çoklu iş parçacığındaki sorun, bu durumun global bir değişkenle veya başka bir şeyle paylaşılıp paylaşılmadığı değil, paylaşılan durumun nasıl doğru şekilde kullanılacağıdır.

Çoğu zaman çoklu iş parçacığı oluştururken bir şey paylaşmanız gerekir. Örneğin, bir üretici-tüketici modelinde, iş birimlerini içeren iş parçacığı açısından güvenli bir kuyruk paylaşabilirsiniz. Ve bu veri yapısı iş parçacığı için güvenli olduğu için paylaşmanıza izin verilir. İş parçacığı güvenliği söz konusu olduğunda, bu kuyruğun küresel olup olmadığı tamamen önemsizdir.

Bu iş parçacığı boyunca, bir programı tek iş parçacığından çok iş parçacığına dönüştürmenin globalleri kullanmamak naif olduğunda daha kolay olacağını ima eden zımni umut. Evet, küreseller kendinizi ayağınızı vurmayı kolaylaştırır, ancak kendinizi vurmanın birçok yolu vardır.

Ben küreselleri savunmuyorum, diğer noktalar hala duruyor gibi, benim amacım sadece bir programda iş parçacığı sayısı değişken kapsamı ile ilgisi yoktur.

Evet, çünkü yetersiz programcıların bunları kullanmasına izin verirseniz (özellikle% 90'ı okuyun) 20+ dosyaya yayılan 600+ küresel değişken ve işlevlerin% 80'inin geçersiz olduğu, geri dönüşü olduğu ve çalıştığı 12.000 satırlık bir proje ile sonuçlanırsınız. tamamen küresel devlet üzerinde.

Tüm projeyi bilmediğiniz sürece, herhangi bir noktada neler olduğunu anlamak imkansız hale gelir.

Kullanımı Küresel değişkenler aslında gereksinimlerine bağlıdır. Avantajı, değerleri tekrar tekrar geçirme yükünü azaltmasıdır.

Ancak profesörünüz haklı çünkü güvenlik sorunlarını gündeme getiriyor, bu nedenle küresel değişkenlerin kullanımından mümkün olduğunca kaçınılmalıdır. Global değişkenler de bazen hata ayıklaması zor olan problemler yaratırlar .

Örneğin:-

Durumlar değişkenler değerler elde edildiğinde modifiye üzerine çalışma zamanı . O anda, kodun hangi bölümünün onu ve hangi koşullarda değiştirdiğini belirlemek zordur.

Konfigürasyon söz konusu olduğunda Global iyidir . Yapılandırmamızın / değişikliklerin tüm proje üzerinde küresel bir etkiye sahip olmasını istediğimizde .

Böylece bir konfigürasyonu değiştirebiliriz ve değişiklikler tüm projeye yönlendirilir . Ama küreselleri kullanmak için çok akıllı olmanız gerektiği konusunda uyarmalıyım.

Er ya da geç bu değişkenin nasıl ayarlandığını ya da erişildiğinde ne olacağını değiştirmelisiniz ya da sadece değiştirildiği yeri bulmanız gerekir.

Küresel değişkenlere sahip olmamak neredeyse her zaman daha iyidir. Sadece baraj alma ve ayarlama yöntemleri yazmak ve bir gün, hafta veya ay sonra onlara ihtiyacınız olduğunda bez olmak.

Genellikle dinamik olarak yüklenen kitaplıktaki işlevlere tek tek veya işlev işaretçileri gibi nadiren değiştirilen değerler için globaller kullanıyorum. Çok iş parçacıklı uygulamalarda mutable global'leri kullanmak, izlenmesi zor olan hataya yol açar, bu yüzden genel bir kural olarak bundan kaçınmaya çalışırım.

Bir argümanı geçmek yerine global kullanmak genellikle daha hızlıdır, ancak günümüzde sıklıkla yaptığınız çok iş parçacıklı bir uygulama yazıyorsanız, genellikle çok iyi çalışmaz (iş parçacığı statiklerini kullanabilirsiniz, ancak performans kazancı tartışmalıdır) .

Bir enterprize içindeki web uygulamalarında, optimizasyon nedeniyle oturum / pencere / iş parçacığı / kullanıcıya özgü verileri sunucuda tutmak ve bağlantının kararsız olduğu yerlerde iş kaybına karşı korumak için kullanılabilir. Belirtildiği gibi, yarış koşullarının ele alınması gerekir. Bu bilgi için bir sınıfın tek bir örneğini kullanıyoruz ve dikkatle yönetiliyor.

Günün sonunda, programınız veya uygulamanız hala çalışabilir, ancak düzenli olma ve neler olup bittiğini tam olarak anlama meselesi. Tüm işlevler arasında değişken bir değer paylaşırsanız, hangi işlevin değeri değiştirdiğini (işlev böyle yaparsa) izlemek zorlaşır ve hata ayıklamayı milyon kez daha zorlaştırır

Güvenlik daha azdır, eğer herhangi biri küresel olarak ilan edilmişse değişkenleri manipüle edebileceği anlamına gelir, bunun için açıklamak için banka programınızda global bir değişken olarak bakiyeniz varsa, kullanıcı fonksiyonu bunu manipüle edebilir ve banka memuru da manipüle edebilir Bu yüzden bir sorun var. sadece kullanıcıya salt okunur ve çekilme fonksiyonu verilmelidir, ancak bankanın katibi, kullanıcı masaya şahsen nakit verdiğinde bu tutarı ekleyebilir.

Çok iş parçacıklı bir uygulamada, bir yarış koşulundan kaçınmak için global değişkenler yerine yerel değişkenleri kullanın.

Birden çok iş parçacığı, paylaşılan bir kaynağa eriştiğinde, en az bir iş parçacığının verilere yazma erişimi olduğunda bir yarış durumu oluşur. Daha sonra, programın sonucu tahmin edilemez ve farklı iş parçacıkları tarafından verilere erişim sırasına bağlıdır.

Bununla ilgili daha fazla bilgi için https://software.intel.com/tr-tr/articles/use-intel-parallel-inspector-to-find-race-conditions-in-openmp-based-multithreaded-code