İşaretçiler / özyineleme hakkında bu kadar zor olan nedir? [kapalı]

Java okullarının tehlikelerinde Joel , Penn'deki deneyimini ve "segmentasyon hatalarının" zorluğunu tartışıyor. Diyor

[siz devam edene kadar segfaultlar zordur] “derin bir nefes alın ve zihninizi aynı anda iki farklı soyutlama seviyesinde çalışmaya zorlamaya çalışın.”

Segfaultların yaygın nedenlerinin bir listesi verildiğinde , 2 soyutlama seviyesinde nasıl çalışmamız gerektiğini anlamıyorum.

Nedense Joel bu kavramları programcıların soyutlama yeteneğinin çekirdeği olarak görüyor. Çok fazla varsaymak istemiyorum. Peki, işaretçiler / özyineleme hakkında bu kadar zor olan ne? Örnekler iyi olurdu.

Öncelikle üniversitede işaretçilerin ve özyinelemenin zor olduğunu fark ettim. Birkaç tipik ilk yıl ders almıştı (biri C ve Assembler, diğeri Scheme idi). Her iki ders de, birçoğu yıllarca lise düzeyinde programlama deneyimi olan yüzlerce öğrenci ile başladı (o günlerde BASIC ve Pascal). Ancak C kursunda işaretçiler tanıtıldığında ve Scheme kursunda özyineleme başlatıldığında, çok sayıda öğrenci - belki de çoğunluğu - tamamen flummoxed edildi. Bunlar daha önce bir sürü LOT kodu yazmış ve hiç problem yaşamamış çocuklardı, ancak işaretçiler ve özyineleme isabet ettiklerinde, bilişsel yetenekleri açısından bir duvara da çarptılar.

Benim hipotezim, işaretçilerin ve özyinelemenin aynı olması, çünkü aynı anda kafanızda iki soyutlama seviyesi tutmanızı gerektiriyor. Bazı insanların asla sahip olamayacakları bir tür zihinsel yetenek gerektiren soyutlamanın çoklu seviyeleri hakkında bir şeyler var.

• İşaretçilerle "iki soyutlama düzeyi", "veri, veri adresi, veri adresi vb." Veya geleneksel olarak "değer ve referans" olarak adlandırdığımız şeydir. Eğitimsiz öğrenci için, x ve x'in adresi arasındaki farkı görmek çok zordur .
• Özyineleme ile, "iki soyutlama düzeyi" bir fonksiyonun kendisini çağırmasının nasıl mümkün olduğunu anlar. Özyinelemeli algoritma, bazen insanların "arzulu düşünerek programlama" dediği şeydir ve bir problemi çözmek için izlediğiniz adımların daha doğal "yerine" temel durum + endüktif durum "açısından bir algoritma düşünmek çok doğal değildir. ." Eğitimsiz öğrenciye özyinelemeli bir algoritmaya bakan algoritma soruya yalvarmaktadır .

Ayrıca, kimseye işaretçiler ve / veya özyineleme öğretmenin mümkün olduğunu kabul etmek için mükemmel bir şekilde istekli olurum ... Herhangi bir şekilde kanıtım yok. Deneysel olarak, bu iki kavramı gerçekten anlayabilmenin, genel programlama yeteneğinin çok ama çok iyi bir öngörücüsü olduğunu ve lisans CS eğitiminin normal seyrinde bu iki kavramın en büyük engellerden bazıları olduğunu biliyorum.

Özyineleme sadece "kendini çağıran bir işlev" değildir. Özyinelemeli iniş ayrıştırıcısında neyin yanlış gittiğini anlamak için yığın kareleri çizene kadar özyinelemenin neden zor olduğunu gerçekten anlamayacaksınız. Çoğunlukla karşılıklı özyinelemeli işlevleriniz olur (A işlevi B işlevini çağırır, C işlevini çağırır, bu işlev A işlevini çağırabilir). Karşılıklı olarak yinelenen bir işlev dizisinde N yığın kareleri olduğunuzda neyin yanlış gittiğini anlamak çok zor olabilir.

Göstergelere gelince, yine işaretçiler kavramı oldukça basittir: bir bellek adresini saklayan bir değişken. Ancak yine, void**farklı düğümlere işaret eden karmaşık veri işaretçilerinizle ilgili bir şeyler ters gittiğinde, işaretçilerinizden birinin neden bir çöp adresini işaret ettiğini anlamaya çalışırken neden zorlanabileceğini göreceksiniz.

Java işaretçileri destekler (bunlara referans denir) ve özyinelemeyi destekler. Yani yüzeyde, argümanı anlamsız görünüyor.

Gerçekten bahsettiği şey hata ayıklama yeteneğidir. Java işaretçisinin (err, başvuru) geçerli bir nesneyi göstermesi garanti edilir. AC işaretçisi değil. Ve c programlamadaki hile, valgrind gibi araçları kullanmadığınızı varsayarsak, tam olarak bir işaretçiyi nerede vidaladığınızı bulmaktır (nadiren bir yığın izinde bulunan noktadadır).

İşaretçiler ve özyineleme ile ilgili problem, anlaşılması zor olmaları değil, özellikle C veya C ++ gibi dillerle ilgili olarak kötü bir şekilde öğretilmesidir (esas olarak dillerin kendilerine kötü öğretildiği için). Ne zaman duyduğumda (veya okuduğumda) birileri "bir dizi sadece bir işaretçi" derken biraz içeride ölürüm.

Benzer şekilde, birisi Fibonacci fonksiyonunu her tekrarladığında göstermek için çığlık atmak istiyorum. Kötü bir örnek çünkü yinelemeli sürümü yazmak daha zor değil ve bu özyinelemeli birden az veya bunlardan daha iyi gerçekleştirir ve bu size bir özyinelemeli çözüm yararlı veya arzu edilir neden içine hiçbir gerçek fikir verir. Quicksort, ağaç geçişi, vb., Özyineleme neden ve nasıl için çok daha iyi örneklerdir.

İşaretçilerle uğraşmak, onları ortaya çıkaran bir programlama dilinde çalışmanın bir eseridir. Nesil Fortran programcıları, özel bir işaretçi türüne (veya dinamik bellek ayırmaya) ihtiyaç duymadan listeler, ağaçlar, yığınlar ve kuyruklar oluşturuyordu ve hiç kimsenin Fortran'ı oyuncak dili olmakla suçladığını duymadım.

İşaretçilerle ilgili çeşitli zorluklar vardır:

1. Örtüşme Farklı nesneler / değişkenler kullanarak bir nesnenin değerini değiştirme olasılığı.
2. Yöresel olmama Bir nesne değerini, bildirildiği değerden farklı bir bağlamda değiştirme olasılığı (bu aynı zamanda referansla iletilen argümanlarda da olur).
3. Ömür Boyu Uyumsuzluk Bir işaretçinin ömrü, işaret ettiği nesnenin ömründen farklı olabilir ve geçersiz referanslara (SEGFAULTS) veya çöplere yol açabilir.
4. İşaretçi Aritmetiği . Bazı programlama dilleri, işaretçilerin tamsayı olarak değiştirilmesine izin verir ve bu, işaretçilerin herhangi bir yeri gösterebileceği anlamına gelir (bir hata olduğunda en beklenmedik yerler dahil). İşaretçi aritmetiğini doğru şekilde kullanmak için, bir programcı işaret edilen nesnelerin bellek boyutlarının farkında olmalıdır ve bu daha düşünülmesi gereken bir şeydir.
5. Yazım Türleri Bir işaretçiyi bir türden diğerine yayınlama yeteneği, bir nesnenin belleğinin amaçlanandan farklı bir belleğinin üzerine yazılmasına olanak tanır.

Bu yüzden bir programcı işaretçiler kullanırken daha iyi düşünmelidir ( iki soyutlama seviyesi hakkında bilmiyorum ). Bu bir acemi tarafından yapılan tipik hataların bir örneğidir:

Pair* make_pair(int a, int b)
{
    Pair p;
    p.a = a;
    p.b = b;
    return &p;
}

Yukarıdaki gibi bir kodun, işaretçi kavramına sahip olmayan, ancak isimler (referanslar), nesneler ve değerlerden biri olan işlevsel programlama dilleri ve çöp toplama (Java, Python) içeren diller için mükemmel bir şekilde makul olduğunu unutmayın. .

Özyinelemeli işlevlerle ilgili zorluk, yeterli matematiksel altyapıya sahip olmayan (özyinelemenin yaygın ve gerekli bilginin olduğu yerlerde) , daha önce çağrıldığına bağlı olarak , işlevin farklı davranacağını düşünerek onlara yaklaşmaya çalıştığında ortaya çıkar . Bu sorun ağırlaşmaktadır çünkü özyinelemeli işlevler gerçekten de bu şekilde düşünmeniz gereken şekillerde oluşturulabilir onları anlamak için .

Veri yapısının yerinde değiştirildiği bir Kırmızı-Siyah Ağacın prosedürel bir uygulamasında olduğu gibi, işaretçiler geçirilen yinelemeli işlevleri düşünün ; düşünmek daha zor bir şeyişlevsel bir meslektaşından .

Soruda bahsedilmiyor, ancak acemilerin zorluk çektiği diğer önemli sorun eşzamanlılıktır .

Diğerlerinin de belirttiği gibi, bazı programlama dili yapılarında ek, kavramsal olmayan bir sorun vardır: anlasak bile, bu yapılarla ilgili basit ve dürüst hataların hatalarını ayıklamak son derece zor olabilir.

İşaretçiler ve özyineleme iki ayrı canavardır ve her birini "zor" olarak nitelendiren farklı nedenler vardır.

Genel olarak, işaretçiler saf değişken atamadan farklı bir zihinsel model gerektirir. Bir işaretçi değişkeni olduğunda, sadece şudur: başka bir nesneye bir işaretçi, içerdiği tek veri işaret ettiği bellek adresidir. Yani örneğin bir int32 işaretçim varsa ve buna doğrudan bir değer atarsam, int değerini değiştirmiyorum, yeni bir bellek adresine işaret ediyorum (bununla yapabileceğiniz çok düzgün hileler var) ). Daha da ilginç olan bir işaretçiye bir işaretçiye sahip olmaktır (bu, bir Ref değişkenini işlev olarak C # 'da geçirdiğinizde olur, işlev Parametreye tamamen farklı bir nesne atayabilir ve bu değer, işlev çıkışlar.

Özyineleme, ilk öğrenirken hafif bir zihinsel sıçrayış gerektirir çünkü bir işlevi kendi başına tanımlıyorsunuz. İlk karşılaştığınız zaman vahşi bir kavramdır, ancak fikri kavradığınızda ikinci doğa olur.

Ama eldeki konuya geri dönelim. Joel'in argümanı, kendi içinde işaretçiler veya özyineleme ile ilgili değildir, aksine öğrencilerin bilgisayarların gerçekte nasıl çalıştığından daha fazla uzaklaştırıldığı gerçeğidir. Bu Bilgisayar Biliminde Bilimdir. Programlamayı öğrenmek ile programların nasıl çalıştığını öğrenmek arasında belirgin bir fark vardır. Pek çok CS programının ticaret okulları yüceltildiğini savunarak bunun "Bu şekilde öğrendim, bu yüzden herkesin bu şekilde öğrenmesi gerekiyor" diye çok fazla bir mesele olduğunu sanmıyorum.

P. Brian'a +1 veriyorum, çünkü öyle hissediyorum: Özyineleme o kadar temel bir kavram ki, onunla en ufak zorlukları olan kişi mac donalds'da bir iş aramayı daha iyi düşünmeli, ama sonra bile özyineleme var:

make a burger:
   put a cold burger on the grill
   wait
   flip
   wait
   hand the fried burger over to the service personel
   unless its end of shift: make a burger

Şüphesiz, anlama eksikliği okullarımızla da ilgilidir. Burada Peano, Dedekind ve Frege gibi doğal sayılar kullanılmalı, bu yüzden daha sonra çok fazla zorluk çekmeyeceğiz.

Joel'e, sorunun kendiliğinden çok sayıda soyutlama düşüncesinden biri olduğuna katılmıyorum, bence işaretçiler ve özyineleme, insanların programların çalışma biçiminde zihinsel modelde bir değişiklik gerektiren sorunlara iki iyi örnek.

İşaretçiler, bence, daha basit bir örnek. İşaretçilerle başa çıkmak, programların gerçekte bellek adresleri ve verilerle çalışma şeklini açıklayan zihinsel bir program yürütme modeli gerektirir. Deneyimlerim, programcıların işaretçiler hakkında bilgi edinmeden önce bunu düşünmediği sık sık oldu. Soyut bir anlamda bilseler bile, bir programın nasıl çalıştığına dair bilişsel modellerine adapte olmamışlardır. İşaretçiler tanıtıldığında, kodun nasıl çalıştığı hakkında düşünme biçiminde köklü bir değişim gerektirir.

Özyineleme sorunludur, çünkü anlaşılması gereken iki kavramsal blok vardır. Birincisi makine düzeyinde ve işaretçiler gibi, programların gerçekte nasıl saklandığını ve yürütüldüğünü iyi anlayarak geliştirilebilir. Özyineleme ile ilgili diğer bir sorun, bence, insanların özyinelemeli bir sorunu özyinelemesiz bir soruna özümsemeye çalışmak için doğal bir eğilime sahip olmalarıdır, bu da özyinelemeli bir fonksiyonun bir gestalt olarak anlaşılmasını çamurlaştırır. Bu ya matematiksel altyapısı yetersiz olan insanlarda ya da matematiksel teoriyi programların gelişimine bağlamayan zihinsel bir modeldir.

Mesele şu ki, işaretçilerin ve özyinelemenin yetersiz bir zihinsel modelde sıkışmış insanlar için sorunlu olan sadece iki alan olduğunu düşünmüyorum. Paralellik, bazı insanların takıldıkları ve zihinsel modellerini hesaba katmakta güçlük çektiği başka bir alan gibi görünüyor, sadece bir röportajda işaretçilerin ve özyinelemenin test edilmesi kolaydır.

  DATA    |     CODE
          |
 pointer  |   recursion    SELF REFERENTIAL
----------+---------------------------------
 objects  |   macro        SELF MODIFYING
          |
          |

Kendinden referanslı veri ve kod kavramı, sırasıyla işaretçilerin ve özyineleme tanımının temelini oluşturur. Ne yazık ki, zorunlu programlama dillerine yaygın maruz kalma, bilgisayar bilimi öğrencilerinin, bu gizemin dilin işlevsel yönüne güvenmesi gerektiğinde, çalışma zamanlarını operasyonel davranışları yoluyla uygulamayı anlamaları gerektiğine inanmalarına neden olmuştur. Yüze kadar tüm sayıların toplanması, birinden başlamak ve sıradaki bir sonrakine eklemek ve dairesel kendinden referans fonksiyonları yardımıyla geriye doğru yapmak basit bir mesele gibi görünüyor. saf fonksiyonlar.

Kendini değiştiren veri ve kod kavramı, sırasıyla nesnelerin (yani akıllı veriler) ve makroların tanımının temelini oluşturur. Bunlardan bahsetmek istiyorum, çünkü özellikle çalışma zamanının dört kavramın bir kombinasyonundan operasyonel bir anlayış beklendiğinde daha da zorlaşıyorlar - örneğin, bir işaretçi ağacı yardımıyla özyinelemeli iyi bir ayrıştırıcı uygulayan bir nesne kümesi üreten bir makro. . Zorunlu programcıların, programın durumunun tüm işleyişini adım adım her bir katman boyunca adım adım izlemek yerine, değişkenlerinin yalnızca saf işlevler içinde bir kez atandığına ve aynı saf işlevin tekrarlanan çağrılarına Java gibi saf olmayan işlevleri de destekleyen bir dilde bile, aynı argümanlar her zaman aynı sonucu verir (yani referans şeffaflığı). Çalışma süresinden sonra çevrelerde koşmak meyvesiz bir çabadır. Soyutlama basitleştirilmelidir.

Anon'un cevabına çok benzer.
Yeni başlayanlar için bilişsel zorlukların yanı sıra, hem işaretçiler hem de özyineleme çok güçlüdür ve şifreli şekillerde kullanılabilir.

Büyük gücün dezavantajı, programınızı ince yollarla sıkıştırmak için size büyük güç veriyorlar.
Sahte bir değeri normal bir değişkene kaydetmek yeterince kötüdür, ancak sahte bir şeyi bir işaretçiye kaydetmek, her türlü gecikmeli felaket olayının gerçekleşmesine neden olabilir.
Ve daha da kötüsü, tuhaf program davranışının nedenini teşhis etmeye / hata ayıklamaya çalıştığınızda bu etkiler değişebilir. Ancak, bir şey incelikle yanlış yapılırsa, neler olduğunu anlamak zor olabilir.

Benzer şekilde özyineleme ile. Gizli veri yapısına (yığın) hileyi doldurarak zor şeyleri organize etmenin çok güçlü bir yolu olabilir.