Dökümden neden kaçınılmalıdır? [kapalı]

Genelde, türlerin dökümünden olabildiğince kaçınıyorum çünkü bunun kötü bir kodlama uygulaması olduğu ve bir performans cezasına çarptırılabileceği izlenimi altındayım.

Ama birisi benden bunun tam olarak neden olduğunu açıklamamı isterse, muhtemelen onlara farların içindeki bir geyik gibi bakardım.

Öyleyse neden / ne zaman kötü oyuncu seçiliyor?

Java, c #, c ++ için genel mi yoksa her farklı çalışma zamanı ortamı bununla kendi şartlarına göre mi ilgileniyor?

Herhangi bir dil için ayrıntılar kabul edilir, örneğin c ++ 'da neden kötü?

Bunu üç dille etiketlediniz ve üçü arasında cevaplar gerçekten oldukça farklı. C ++ 'ın tartışılması aşağı yukarı C dökümlerinin tartışılması anlamına gelir ve bu (aşağı yukarı) dördüncü bir cevap verir.

Açıkça bahsetmediğin olduğundan, C ile başlayacağım. C yayınlarının bir takım sorunları var. Birincisi, birçok farklı şeyi yapabilmeleridir. Bazı durumlarda, cast derleyiciye şunu söylemekten başka bir şey yapmaz (özünde): "Kapa çeneni, ne yaptığımı biliyorum" - yani sorunlara neden olabilecek bir dönüştürme yaptığınızda bile derleyicinin sizi bu potansiyel sorunlar hakkında uyarmayacaktır. Sadece örneğin char a=(char)123456;. Bu uygulamanın kesin sonucu tanımlanmıştır (boyutuna ve imzasına bağlıdır.char) ve oldukça garip durumlar haricinde, muhtemelen yararlı değildir. C yayınları, yalnızca derleme zamanında gerçekleşen bir şey olup olmadıklarına (yani derleyiciye yalnızca bazı verileri nasıl yorumlayacağını / işleyeceğini söylüyorsunuz) veya çalışma zamanında gerçekleşen bir şey olup olmadığına (örneğin, ikiye kattan uzun).

C ++, her biri bir C dökümünün yeteneklerinin sadece bir alt kümesiyle sınırlı olan bir dizi "yeni" döküm operatörü ekleyerek en azından bir dereceye kadar bununla başa çıkmaya çalışır. Bu, (örneğin) gerçekten istemediğiniz bir dönüşümü yanlışlıkla yapmayı zorlaştırır - eğer sadece bir nesneye sadakati atmak istiyorsanız, kullanabilirsiniz const_castve bunun etkileyebileceği tek şeyin olup olmadığına emin olun. bir amacı const, volatile, ya da. Bunun tersine, bir static_castamacı, etkili olup izin verilmez constveyavolatile. Kısacası, aynı tür yeteneklerin çoğuna sahipsiniz, ancak bunlar kategorize edildiğinden, bir oyuncu genellikle yalnızca bir tür dönüştürme yapabilir, burada tek bir C-stili kadro, bir işlemde iki veya üç dönüştürme yapabilir. Birincil istisna olmasıdır olabilir bir kullanmak dynamic_castbir yerine static_casten azından bazı durumlarda ve şeklinde yazılır rağmen dynamic_cast, gerçekten olarak bitireceğiz static_cast. Örneğin, dynamic_castbir sınıf hiyerarşisini yukarı veya aşağı hareket ettirmek için kullanabilirsiniz - ancak hiyerarşiyi "yukarı" çevirmek her zaman güvenlidir, bu nedenle statik olarak yapılabilir, ancak hiyerarşiyi "aşağı" çevirmek her zaman güvenli değildir, bu nedenle dinamik olarak yapılır.

Java ve C # birbirine çok daha benzer. Özellikle, her ikisinde de döküm (neredeyse?) Her zaman bir çalışma zamanı işlemidir. C ++ döküm operatörleri dynamic_castaçısından, gerçekte ne yapıldığına göre genellikle a'ya en yakın olanıdır - yani, bir nesneyi bir hedef türüne atmaya çalıştığınızda, derleyici bu dönüşüme izin verilip verilmediğini görmek için bir çalışma zamanı kontrolü ekler. ve değilse bir istisna atın. Kesin ayrıntılar (örneğin, "kötü dönüştürme" istisnası için kullanılan ad) değişiklik gösterir, ancak temel ilke çoğunlukla benzer kalır (ancak, bellek hizmet veriyorsa, Java, intC'ye çok daha yakın gibi birkaç nesne olmayan türe uygulanmış yayınlar yapar. yayınlar - ancak bu türler yeterince nadir kullanılır ki 1) Bunu kesin olarak hatırlamıyorum ve 2) doğru olsa bile, zaten pek bir önemi yok).

Her şeye daha genel bakıldığında, durum oldukça basittir (en azından IMO): bir oyuncu kadrosu (açıkça yeterli), bir şeyi bir türden diğerine dönüştürdüğünüz anlamına gelir. Bunu ne zaman / yaparsanız, "Neden?" Sorusunu gündeme getirir. Bir şeyin gerçekten belirli bir tür olmasını istiyorsanız, neden onu başlangıçta bu tür olarak tanımlamadınız? Bu , böyle bir dönüştürme yapmak için hiçbir zaman bir neden olmadığı anlamına gelmez, ancak bu ne zaman olursa olsun, baştan sona doğru türün kullanılması için kodu yeniden tasarlayıp tasarlayamayacağınız sorusunu sormalıdır. Görünüşte zararsız dönüşümler bile (örneğin, tam sayı ve kayan nokta arasındaki) yaygın olandan çok daha yakından incelenmelidir. Görünüşlerine rağmenbenzerlik, tamsayılar "sayılan" türdeki şeyler için ve "ölçülen" türdeki şeyler için kayan nokta kullanılmalıdır. Ayrımı göz ardı etmek, "ortalama bir Amerikan ailesinin 1.8 çocuğu var" gibi bazı çılgın ifadelere yol açan şeydir. Bunun nasıl olduğunu hepimiz görebiliyor olsak da, gerçek şu ki hiçbir ailenin 1.8 çocuğu yok. 1 veya 2 olabilir veya daha fazlasına sahip olabilirler - ama asla 1.8.

Burada birçok iyi cevap var. İşte ona bakma şeklim (C # açısından).

Oyuncu seçimi genellikle iki şeyden biri anlamına gelir:

• Bu ifadenin çalışma zamanı türünü biliyorum ancak derleyici bunu bilmiyor. Derleyici, size söylüyorum, çalışma zamanında bu ifadeye karşılık gelen nesne gerçekten bu türden olacaktır. Şu an itibariyle, bu ifadenin bu türden muamele görmesi gerektiğini biliyorsunuz. Nesnenin belirtilen türde olacağını varsayan kod oluşturun veya yanılıyorsam bir istisna atın.

• Hem derleyici hem de geliştirici ifadenin çalışma zamanı türünü bilir. Bu ifadenin çalışma zamanında sahip olacağı değerle ilişkili farklı türde başka bir değer var. Verilen türün değerinden istenen türün değerini üreten kod oluşturun; bunu yapamazsanız, bir istisna atın.

Bunların zıt olduğuna dikkat edin . İki tür yayın var! Derleyiciye gerçeklik hakkında bir ipucu verdiğiniz yayınlar var - hey, bu nesne türü aslında Müşteri türündedir - ve derleyiciye bir türden diğerine bir eşleme yapmasını söylediğiniz yayınlar vardır - hey, Bu çifte karşılık gelen int'e ihtiyacım var.

Her iki tür atış da kırmızı bayraktır. İlk tür oyuncu kadrosu, "neden geliştiricinin derleyicinin bilmediği bir şeyi bildiği tam olarak nedir?" Sorusunu gündeme getirir. O durumda ise o zaman yapacak daha iyi bir şey derleyici böylece programı değiştirmek genellikle gelmez gerçeklik üzerindeki kolu var. O zaman oyuncu kadrosuna ihtiyacınız yok; analiz derleme zamanında yapılır.

İkinci tür uygulama, "neden ilk etapta hedef veri türünde işlem yapılmıyor?" Sorusunu gündeme getiriyor. İnts'de bir sonuca ihtiyacınız varsa, o zaman neden ilk başta bir çift tutuyorsunuz? Bir int tutman gerekmiyor mu?

Burada bazı ek düşünceler:

http://blogs.msdn.com/b/ericlippert/archive/tags/cast+operator/

Döküm hataları her zaman java'da çalışma zamanı hataları olarak rapor edilir. Jenerik veya şablon kullanmak, bu hataları derleme zamanı hatalarına dönüştürerek, bir hata yaptığınızda bunu tespit etmeyi çok daha kolay hale getirir.

Yukarıda söylediğim gibi. Bu, tüm oyuncu seçimlerinin kötü olduğu anlamına gelmez. Ancak bundan kaçınmak mümkünse, en iyisi bunu yapmaktır.

Oyuncu seçimi, doğası gereği kötü değildir, sadece ya hiç yapılmaması ya da daha zarif bir şekilde yapılması gereken bir şeyi elde etmek için sıklıkla kötüye kullanılır.

Evrensel olarak kötü olsaydı, diller bunu desteklemezdi. Diğer herhangi bir dil özelliği gibi, onun da yeri vardır.

Tavsiyem, ana dilinize odaklanmak ve tüm yayınlarını ve ilişkili en iyi uygulamaları anlamak olacaktır. Bu, gezileri diğer dillere bildirmelidir.

İlgili C # belgeleri buradadır .

Burada önceki bir SO sorusunda C ++ seçeneklerinin harika bir özeti var .

Çoğunlukla C ++ için konuşuyorumBurada , ancak bunların çoğu muhtemelen Java ve C # için de geçerlidir:

C ++, statik olarak yazılmış bir dildir . Dilin bu konuda size izin verdiği bazı yollar vardır (sanal işlevler, örtük dönüştürmeler), ancak temelde derleyici her nesnenin türünü derleme zamanında bilir. Böyle bir dil kullanmanın nedeni, hataların derleme sırasında yakalanabilmesidir . Derleyici türlerini biliyorsaa ve b, bunu yaptığında o zaman derleme sırasında sizi yakalayacak a=bnerede akarmaşık bir sayıdır ve bbir dizedir.

Açıkça döküm yaptığınızda, derleyiciye susmasını söylersiniz çünkü daha iyi bildiğinizi düşünürsünüz . Yanılıyorsanız, genellikle sadece çalışma anında öğrenirsiniz . Ve çalışma zamanında öğrenmedeki sorun, bunun bir müşteride olabileceğidir.

Java, c # ve c ++ güçlü biçimde yazılmış dillerdir, ancak güçlü biçimde yazılmış diller esnek olarak görülmese de, derleme zamanında tür denetimi yapma avantajına sahiptirler ve sizi belirli işlemler için yanlış türe sahip olmanın neden olduğu çalışma zamanı hatalarına karşı korurlar.

Temelde iki tür yayın vardır: daha genel bir türe dönüştürme veya başka bir türe dönüştürme (daha spesifik). Daha genel bir türe çevrim (bir ana türe çevrim) derleme zamanı kontrollerini olduğu gibi bırakacaktır. Ancak diğer türlere (daha spesifik türler) çevrim, derleme zamanı türü denetimini devre dışı bırakır ve derleyici tarafından bir çalışma zamanı denetimi ile değiştirilir. Bu, derlediğiniz kodun doğru çalışacağından daha az emin olduğunuz anlamına gelir. Ayrıca, ekstra çalışma zamanı türü denetimi nedeniyle bazı önemsiz performans etkisine sahiptir (Java API'si yayınlarla doludur!).

Bazı döküm türleri o kadar güvenli ve etkilidir ki çoğu zaman döküm olarak bile düşünülmez.

Türetilmiş bir türden temel türe çevirirseniz, bu genellikle oldukça ucuzdur (genellikle - dile, uygulamaya ve diğer faktörlere bağlı olarak - sıfır maliyetlidir) ve güvenlidir.

Int gibi basit bir türden long int gibi daha geniş bir türe çevirirseniz, genellikle oldukça ucuzdur (genellikle aynı türü atamaktan çok daha pahalı değildir) ve yine güvenlidir.

Diğer türler daha zahmetli ve / veya daha pahalıdır. Çoğu dilde temel türden türetilmiş türe çevrim ya ucuzdur, ancak ciddi hata riski yüksektir (C ++ 'da, temelden türetilene static_cast uygularsanız ucuz olacaktır, ancak temel değer türetilmiş türden değilse davranış tanımsızdır ve çok tuhaf olabilir) veya görece pahalı olabilir ve bir istisna oluşturma riski vardır (C ++ 'da dinamik yayın, C #' da açık temelden türetilmiş dönüştürme, vb.). Java ve C # ile boks yapmak bunun başka bir örneğidir ve daha da büyük bir masraftır (temel değerlerin nasıl ele alındığından daha fazla değiştiklerini düşünürsek).

Diğer tür çevirme türleri bilgileri kaybedebilir (uzun bir tam sayı türünden kısa bir tam sayı türüne).

Bu risk durumları (ister istisna ister daha ciddi bir hata olsun) ve masraflar, dökümden kaçınmak için tüm nedenlerdir.

Daha kavramsal ama belki de daha önemli bir neden, her bir döküm vakasının, kodunuzun doğruluğu hakkında akıl yürütme yeteneğinizin engellendiği bir durum olmasıdır: Her vaka, bir şeylerin ters gidebileceği başka bir yerdir ve bunun yolları yanlış gidebilir, sistemin bir bütün olarak yanlış gidip gitmeyeceğini çıkarmanın karmaşıklığına eklenir. Oyuncu kadrosu her seferinde kanıtlanabilir şekilde güvenli olsa bile, bunun mantığın fazladan bir parçası olduğunu kanıtlamak.

Son olarak, yayınların yoğun kullanımı, nesne modelini ya onu oluştururken, kullanırken ya da her ikisinde de iyi değerlendirememe anlamına gelebilir: Aynı birkaç tür arasında sık sık ileri geri hareket etmek, neredeyse her zaman türler arasındaki ilişkileri dikkate almamaktır. Kullanılmış. Burada, kötü bir şeyin işareti oldukları için oyuncuların kötü olması o kadar da önemli değil.

Programcılar için, dil özelliklerinin kullanımıyla ilgili dogmatik kurallara ("asla XXX kullanmayın!", "XXX zararlı kabul edilir", vb.) Bağlı kalma eğilimi artmaktadır; burada XXX, gotos'den işaretçilere, protectedveri üyelerine, tekillere ve nesnelerin geçişine kadar değişmektedir. değer.

Tecrübelerime göre bu tür kurallara uymak iki şeyi garanti eder: Ne kötü bir programcı ne de harika bir programcı olacaksınız.

Çok daha iyi bir yaklaşım, bu kapsamlı yasakların ardındaki hakikatin çekirdeğini kazmak ve ortaya çıkarmak ve daha sonra , bu iş için en iyi araç size ait olan birçok durum.

"Genelde türlerin dökümünden olabildiğince kaçınırım" böyle aşırı genelleştirilmiş bir kuralın güzel bir örneğidir. Oyuncular birçok yaygın durumda gereklidir. Bazı örnekler:

1. Üçüncü taraf kodla birlikte çalışırken (özellikle bu kod typedefs ile yaygın olduğunda ). (Örnek: GLfloat<--> double<-->Real .)
2. Türetilmiş bir temel sınıf işaretçisi / başvurusundan çevrim: Bu o kadar yaygın ve doğal ki derleyici bunu dolaylı olarak yapacaktır. Açıkça yapmak okunabilirliği artırıyorsa, oyuncu kadrosu geriye doğru değil, ileriye doğru bir adımdır!
3. Bir tabandan türetilmiş sınıf işaretçisi / referansına çevrim: İyi tasarlanmış kodda bile yaygın olarak kullanılır. (Örnek: heterojen kaplar.)
4. Yerleşik türlerin ham baytlarına erişim gerektiren ikili serileştirme / seriyi kaldırma veya diğer düşük düzeyli kodlar içinde.
5. Farklı bir türü kullanmak için daha doğal, kullanışlı ve okunabilir olduğu her zaman. (Örnek: std::size_type-> int.)

Bir alçı kullanmanın uygun olmadığı pek çok durum vardır ve bunları öğrenmek de önemlidir; Yukarıdaki cevaplar bazılarını işaret ederek iyi bir iş çıkardığından çok fazla detaya girmeyeceğim.

KDeveloper'in cevabını detaylandırmak gerekirse , doğası gereği tip güvenli değildir. Yayınlama ile, yayınladığınız ve yayınladığınız şeyin eşleşeceğinin garantisi yoktur ve bu gerçekleşirse, her zaman kötü bir şey olan bir çalışma zamanı istisnası alırsınız.

C # ile ilgili özel olarak, isve asişleçlerini içerdiği için, bir aletin başarılı olup olmayacağına (çoğunlukla) karar verme fırsatına sahipsiniz. Bu nedenle, operasyonun başarılı olup olmayacağını ve uygun şekilde ilerleyip ilerlemeyeceğini belirlemek için uygun adımları atmalısınız.

C # durumunda, değer türleri ile uğraşırken ilgili kutulama / kutudan çıkarma ek yükleri nedeniyle döküm sırasında daha dikkatli olunması gerekir.

Birinin bundan daha önce bahsettiğinden emin değilim, ancak C # dökümünde oldukça güvenli bir şekilde kullanılabilir ve genellikle gereklidir. Birkaç türde olabilen bir nesne aldığınızı varsayalım. KullanmakisAnahtar kelimeyi önce nesnenin gerçekten onu çevirmek üzere olduğunuz türde olduğunu onaylayabilir ve ardından nesneyi doğrudan bu türe çevirebilirsiniz. (Java ile pek çalışmadım ama eminim orada da yapmanın çok basit bir yolu vardır).

Bir nesneyi yalnızca 2 koşul karşılanırsa bir türe çevirirsiniz:

1. bu türden olduğunu biliyorsun
2. derleyici yapmaz

Bu, sahip olduğunuz tüm bilgilerin kullandığınız tür yapısında iyi temsil edilmediği anlamına gelir. Bu kötü, çünkü uygulamanız anlamsal olarak olarak modelinizi , bu durumda açıkça görülmez.

Şimdi bir kadro yaptığınızda, bunun 2 farklı nedeni olabilir:

1. Tipik ilişkileri ifade etmekte kötü bir iş çıkardın.
2. dil türü sistemi onları ifade edecek kadar açıklayıcı değil.

Çoğu dilde birçok kez 2. durumla karşılaşırsınız. Java'daki gibi jenerikler biraz yardımcı olur, C ++ şablon sistemi daha da fazla, ancak ustalaşması zordur ve o zaman bile bazı şeyler imkansız olabilir veya çabaya değmeyebilir.

Yani diyebilirsiniz ki, belirli bir dilde belirli bir tür ilişkiyi ifade etmek için problemlerinizi aşmak için yapılan kirli bir hack. Kirli saldırılardan kaçınılmalıdır. Ama onlarsız asla yaşayamazsınız.

Genel olarak şablonlar (veya jenerikler), yayınlardan daha güvenlidir. Bu bağlamda, döküm ile ilgili bir sorunun tip güvenliği olduğunu söyleyebilirim. Ancak, özellikle aşağı değerlendirme ile ilgili daha ince bir sorun daha var: tasarım. En azından benim bakış açıma göre, aşağı izleme bir kod kokusu, tasarımımda bir şeylerin yanlış olabileceğinin bir göstergesi ve daha fazla araştırmam gerekiyor. Neden basit: Eğer soyutlamaları doğru "anlarsanız", buna ihtiyacınız yoktur! Bu arada güzel soru ...

Şerefe!

Gerçekten özlü olmak gerekirse, iyi bir neden taşınabilirliktir. Her ikisi de aynı dili barındıran farklı mimari, örneğin farklı boyutlara sahip olabilir. Dolayısıyla, ArchA'dan daha dar bir int'e sahip olan ArchB'ye geçersem, en iyi ihtimalle tuhaf davranış ve en kötü ihtimalle segment hatası görebilirim.

(Açıkça mimariden bağımsız bayt kodunu ve IL'yi görmezden geliyorum.)