"C ++ kodlama standartları" okuyordu ve bu satır vardı:
Değişkenler durumu ortaya çıkarır ve mümkün olduğunca az durumla, mümkün olduğunca kısa ömürlerle uğraşmanız gerekir.
Mutasyona uğrayan hiçbir şey sonunda durumu manipüle etmez mi? Mümkün olduğunca az devletle uğraşmak için ne yapmanız gerekir ?
C ++ gibi saf olmayan bir dilde, durum yönetimi gerçekten ne yaptığınızı değil mi? Değişken yaşam süresini sınırlamaktan başka mümkün olduğunca az durumla başa çıkmanın başka yolları nelerdir?
Yanıtlar:
Değişken herhangi bir şey gerçekten durumu manipüle etmez mi?
Evet.
Peki "küçük devletle uğraşmak zorundasın" ne anlama geliyor?
Bu, daha az devletin, daha fazla devletten daha iyi olduğu anlamına gelir. Daha fazla devlet daha fazla karmaşıklık getirme eğilimindedir.
C ++ gibi saf olmayan bir dilde, devlet yönetimi gerçekten yaptığınız şey değil mi?
Evet.
Değişken ömrünü sınırlamaktan başka "az devletle başa çıkmanın" başka yolları nelerdir?
Değişken sayısını en aza indirin. Bazı kodları kendi kendine yeten bir birime yönlendiren kodu diğer kod bölümlerinin yok sayabilmesi için ayırın.
Değişken herhangi bir şey gerçekten durumu manipüle etmez mi?
Evet. C ++ 'da, değişebilen tek şey (non const) değişkenleridir.
Peki "küçük devletle uğraşmak zorundasın" ne anlama geliyor?
Bir program ne kadar az duruma sahipse, ne yaptığını anlamak o kadar kolay olur. Bu yüzden gerekli olmayan bir durumu tanıtmamalısınız ve artık ihtiyacınız olmadığında tutmamalısınız.
C ++ gibi saf olmayan bir dilde, devlet yönetimi gerçekten yaptığınız şey değil mi?
C ++ gibi çoklu paradigma dillerinde, genellikle "saf" bir işlev ya da devlet güdümlü bir yaklaşım ya da bir çeşit melez arasında bir seçenek vardır. Tarihsel olarak, işlevsel programlama için dil desteği bazı dillere kıyasla oldukça zayıftı, ancak gelişiyor.
Değişken ömrünü sınırlamaktan başka "az devletle başa çıkmanın" başka yolları nelerdir?
Nesneler arasındaki bağlantıyı azaltmak için kapsamı ve kullanım ömrünü kısıtlayın; küresel değişkenlerden ziyade yerel, kamusal nesne üyelerinden ziyade özel.
durumu , bir şeyin bir yerde saklandığı anlamına gelir; böylece daha sonra başvurabilirsiniz.
Değişken oluşturmak, bazı verileri depolamanız için biraz alan yaratır. Bu veriler programınızın durumudur .
Bunu kullanarak bir şeyler yapmak, değiştirmek, hesaplamak vb. İçin kullanırsınız.
Bu durum size şeyler oysa yapmak devlet değildir.
İşlevsel bir dilde, çoğunlukla yalnızca nesneler gibi işlevler ve etraftaki işlevler ile ilgilenirsiniz. Bu işlevlerin durumu olmasa da ve işlevin etrafından geçilmesine rağmen hiçbir durum getirmez (belki işlevin içinde olabilir).
C ++ oluşturabilir fonksiyon nesneleri vardır, structya classgelmiş türleri operator()()aşırı yüklendi. Bu işlev nesnelerinin yerel durumu olabilir, ancak programınızdaki diğer kodlar arasında paylaşılması gerekmez. Fonksiyonerlerin (yani fonksiyon nesneleri) etrafta dolaşması çok kolaydır. Bu, C ++ 'da işlevsel bir paradigmayı taklit edebileceğiniz kadar yakındır. (BİLDİĞİM KADARIYLA)
Durumun az olması veya hiç olmaması, programınızı paralel yürütme için kolayca optimize edebileceğiniz anlamına gelir, çünkü iş parçacıkları veya CPU'lar arasında paylaşılabilecek hiçbir şey yoktur, bu nedenle çekişmenin yaratılabileceği hiçbir şey ve veri yarışlarına vb. Karşı korumak zorunda olduğunuz hiçbir şey yoktur.
Diğerleri ilk 3 soruya iyi cevaplar verdiler.
Değişken ömrünü sınırlamaktan başka "mümkün olduğunca az durumla başa çıkmanın" başka yolları nelerdir?
1 numaralı sorunun temel cevabı evet, sonunda mutasyona uğrayan her şey durumu etkiler. Daha sonra anahtar etmektir değil mutasyon şeyler. Bir fonksiyonun sonucunun doğrudan diğerine geçirildiği ve saklanmadığı, durum depolamak yerine doğrudan mesaj veya olay geçirdiği, bunları saklamak ve güncellemek yerine değerleri hesaplayan fonksiyonel bir programlama stili kullanan değişmez tipler ...
Aksi takdirde, devletin etkisini sınırlamakla kalmazsınız; görünürlük veya ömür boyu.
Peki "küçük devletle uğraşmak zorundasın" ne anlama geliyor?
Bu, sınıflarınızın olabildiğince küçük olması ve en iyi şekilde tek bir soyutlamayı temsil etmesi gerektiği anlamına gelir. Sınıfınıza 10 değişken koyarsanız, büyük olasılıkla yanlış bir şey yapıyorsunuzdur ve sınıfınızı nasıl yeniden düzenleyeceğinizi görmelisiniz.
Bir programın nasıl çalıştığını anlamak için, programın durum değişikliklerini anlamalısınız. Ne kadar az duruma sahip olursanız ve onu kullanan koda ne kadar yerel olursa, bu o kadar kolay olur.
Çok sayıda küresel değişken içeren bir programla çalışsaydınız, dolaylı olarak anlarsınız.
Durum basitçe saklanan verilerdir. Her değişken bir çeşit durumdur, ancak genellikle işlemler arasında kalıcı olan verilere atıfta bulunmak için "durum" kullanırız. Basit ve anlamsız bir örnek olarak, dahili intve sahip increment()ve decrement()üye işlevlerini dahili olarak saklayan bir sınıfınız olabilir . Burada, iç değer devlettir, çünkü bu sınıfın örneğinin ömrü boyunca devam eder. Başka bir deyişle, değer nesnenin durumudur.
İdeal olarak, bir sınıfın tanımladığı durum, minimum fazlalık ile mümkün olduğunca küçük olmalıdır. Bu, sınıfınızın tek sorumluluk ilkesini karşılamasına yardımcı olur , kapsüllemeyi geliştirir ve karmaşıklığı azaltır. Bir nesnenin durumu, o nesneye arabirim tarafından tamamen kapsüllenmelidir. Bu, nesnenin semantiği göz önüne alındığında, o nesne üzerindeki herhangi bir işlemin sonucunun tahmin edilebileceği anlamına gelir. Duruma erişimi olan işlev sayısını en aza indirerek kapsüllemeyi daha da geliştirebilirsiniz .
Bu, küresel devletten kaçınmanın başlıca nedenlerinden biridir. Genel durum, arabirimi ifade etmeden bir nesneye bağımlılık getirebilir ve bu durumu bu nesneyi kullanıcıdan uzak tutar. Genel bağımlılığa sahip bir nesne üzerinde işlem başlatmak, farklı ve öngörülemeyen sonuçlar doğurabilir.
Mutasyona uğrayan hiçbir şey sonunda durumu manipüle etmez mi?
Evet, ancak tüm sistemdeki özel durumunu değiştirebilen tek varlık olan küçük bir sınıfın üye işlevinin arkasındaysa, bu durumun çok dar bir kapsamı vardır.
Mümkün olduğunca az devletle uğraşmak için ne yapmanız gerekir?
Değişkenin bakış açısından: mümkün olduğu kadar az kod satırı erişebilmelidir. Değişkenin kapsamını minimuma indirir.
Kod satırının bakış açısından: bu kod satırından mümkün olduğunca az sayıda değişken erişilebilir olmalıdır. Kod satırının ki değişkenlerin sayısını daraltın muhtemelen erişim (hatta o olsun o kadar önemli değildir does hususlar bu olup olmadığıdır Hepsi bu erişim o can ).
Global değişkenler o kadar kötü ki maksimum kapsamı var. Bir kod tabanındaki 2 kod satırından, kod satırının POV'sinden erişilse bile, global bir değişkene her zaman erişilebilir. Değişkenin POV'sinden, dış bağlantıya sahip global bir değişkene, tüm kod tabanındaki her bir kod satırına (veya yine de başlığı içeren her bir kod satırına) erişilebilir. Yalnızca 2 satır kodla erişilmesine rağmen, global değişken 400.000 satır koduna görünürse, geçersiz bir duruma ayarlandığını gördüğünüzde anında şüphelenilen listenizin 400.000 girişi olacaktır (belki de Araçlarla 2 giriş, ancak yine de, acil listede 400.000 şüpheli olacak ve bu cesaret verici bir başlangıç noktası değildir).
Benzer şekilde, küresel bir değişken kod tabanının tamamında yalnızca 2 satır kodla değiştirilmeye başlasa bile, kod tabanlarının geriye doğru gelişmeye yönelik talihsiz eğilimi, bu sayıyı büyük ölçüde artırma eğiliminde olacaktır, çünkü geliştiriciler, son teslim tarihlerini karşılamak için çılgınca, bu küresel değişkeni görüyor ve bunun üzerinden kısayollar alabileceklerinin farkındalar.
C ++ gibi saf olmayan bir dilde, durum yönetimi gerçekten ne yaptığınızı değil mi?
Büyük ölçüde, evet, C + 'yı, özel yapım değişmez veri yapıları ve saf fonksiyonel programlama ile uğraştığınız çok egzotik bir şekilde kullanmadığınız sürece - aynı zamanda devlet yönetimi karmaşıklaştığında ve karmaşıklık olduğunda çoğu hatanın kaynağıdır. genellikle bu durumun görünürlüğünün / maruziyetinin bir fonksiyonu.
Değişken yaşam süresini sınırlamaktan başka mümkün olduğunca az durumla başa çıkmanın başka yolları nelerdir?
Bunların hepsi bir değişkenin kapsamını sınırlama alanındadır, ancak bunu yapmanın birçok yolu vardır:
30,000*20=600,000. Bunun üstünde erişilebilir 10 küresel değişken olsaydı, devlet karmaşıklığı böyle olabilir 30,000*(20+10)=900,000. Sağlıklı bir "devlet karmaşıklığı" (kişisel tür icat ettiğim metrik), on binlerce değil, kesinlikle yüz binlerce değil, sınıflar için binlerce veya altında olmalıdır. Serbest fonksiyonlar için, bakımda ciddi baş ağrıları görmeye başlamadan önce yüzlerce veya daha az diyelim.Değişkenlerin Ötesinde: Yan Etkiler
Yukarıda listelediğim bu yönergelerin birçoğu ham, değişken duruma (değişkenlere) doğrudan erişim ile mücadele ediyor. Ancak yeterince karmaşık bir kod tabanında, ham değişkenlerin kapsamını daraltmak, doğruluk hakkında kolayca akıl yürütmek için yeterli olmayacaktır.
Diyelim ki, tamamen SOLID, soyut bir arayüzün arkasında, değişmezleri mükemmel bir şekilde koruyabilen ve bu merkezi durumun geniş pozlaması nedeniyle hala çok fazla kederle karşılaşan merkezi bir veri yapısına sahip olabilirsiniz. Mutlaka küresel olarak erişilebilir olmayan ancak yalnızca geniş çapta erişilebilir olan bir merkezi durum örneği, bir oyun motorunun merkezi sahne grafiği veya Photoshop'un merkezi katman veri yapısıdır.
Bu gibi durumlarda, "devlet" fikri ham değişkenlerin ötesine geçer ve sadece veri yapılarına ve bu tür şeylere gider. Aynı şekilde kapsamlarını azaltmaya yardımcı olur (onları dolaylı olarak mutasyona uğratan işlevler çağırabilecek satır sayısını azaltın).
Geniş, uzaklaştırılmış mimari düzeyden dolaylı da olsa bu arayüze erişim hâlâ mutasyona uğradığı için arayüzü kasıtlı olarak burada kırmızı olarak nasıl işaretlediğime dikkat edin. Sınıf, değişmezleri arayüzün bir sonucu olarak koruyabilir, ancak bu sadece doğruluk hakkında akıl yürütme yeteneğimiz açısından çok ileri gider.
Bu durumda, merkezi veri yapısı küresel olarak erişilemeyen soyut bir arayüzün arkasındadır. Karmaşık kod tabanınızdaki bir tekne yükü işlevinden yalnızca enjekte edilebilir ve daha sonra dolaylı olarak (üye işlevleri aracılığıyla) dönüştürülebilir.
Böyle bir durumda, veri yapısı kendi değişmezlerini mükemmel bir şekilde muhafaza etse bile, daha geniş bir seviyede garip şeyler olabilir (örn: bir ses çalar, ses seviyesinin asla% 0 aralığının dışına çıkmaması gibi her türlü değişmezi koruyabilir % 100, ancak bu, oynat düğmesine basan ve bir etkinlik olarak oynatmaya en son yüklediği ses dışında rastgele bir ses klibine sahip olan kullanıcıyı korumaz, bu da oynatma listesinin geçerli bir şekilde yeniden karıştırılmasına neden olur, ancak hala istenmeyen, geniş kullanıcı perspektifinden glitchy davranışı).
Bu karmaşık senaryolarda kendinizi korumanın yolu, kod tabanındaki, ham durumun ötesine ve arayüzlerin ötesine geçen sistemin bu tür daha geniş bir görüşünden bile sonuçta harici yan etkilere neden olabilecek işlevleri "darboğaz" haline getirmektir.
Göründüğü kadar garip, hiçbir "durum" a (kırmızı ile gösterilen ve bu "ham değişken" anlamına gelmez, sadece bir "nesne" anlamına gelir ve muhtemelen soyut bir arayüzün arkasında) çok sayıda yerden erişildiğini görebilirsiniz. . İşlevlerin her biri, merkezi bir güncelleyici tarafından da erişilebilen bir yerel duruma erişebilir ve merkezi duruma yalnızca merkezi güncelleyici tarafından erişilebilir (artık merkezi değil, doğada yereldir).
Bu, yalnızca 10 milyon kod satırını kapsayan bir oyun gibi gerçekten karmaşık kod tabanları içindir, ancak yazılımınızın doğruluğu hakkında muhakemede büyük ölçüde yardımcı olabilir ve sayınızı önemli ölçüde sınırlandırdığınızda / tıklattığınızda değişikliklerinizin öngörülebilir sonuçlar verdiğini bulmak tüm mimarinin doğru işlev görmesi için döndüğü kritik durumları değiştirebilen yerler.
Ham değişkenlerin ötesinde dış yan etkiler vardır ve dış yan etkiler, birkaç üye işlevle sınırlı olsalar bile bir hata kaynağıdır. Bir tekne yükü işlevi, bu avuç üyesi işlevlerini doğrudan çağırabiliyorsa, sistemde dolaylı olarak harici yan etkilere neden olabilecek ve karmaşıklığı artıran bir tekne yükü işlevi vardır. Kod tabanında bu üye işlevlere erişimi olan tek bir yer varsa ve bir yürütme yolu her yerde sporadik olaylar tarafından tetiklenmezse, bunun yerine çok kontrollü, öngörülebilir bir şekilde yürütülürse, karmaşıklığı azaltır.
Devlet Karmaşıklığı
Devletin karmaşıklığı bile dikkate alınması gereken önemli bir faktördür. Soyut bir arayüzün arkasından geniş bir şekilde erişilebilen basit bir yapıyı karıştırmak o kadar da zor değildir.
Karmaşık bir mimarinin temel mantıksal temsilini temsil eden karmaşık bir grafik veri yapısını karıştırmak oldukça kolaydır ve grafiğin değişmezlerini bile ihlal etmeyecek şekilde. Bir grafik, basit bir yapıdan çok daha karmaşıktır ve bu nedenle böyle bir grafik yapısına erişimi olan yerlerin sayısını mutlak minimuma indirmek için kod tabanının algılanan karmaşıklığını azaltmak daha da önemli hale gelir, ve sporadik önlemek için bir çekme paradigmasını tersine çeviren bu tür "merkezi güncelleyici" stratejisi, her yerden grafik veri yapısına doğrudan itebilir.