OOP uygulamada hangi prosedürel programlama problemlerini çözüyor?


17

"C ++ Demystified" kitabını inceledim . Şimdi okumaya başladım "Turbo C ++ birinci basımda Nesneye Yönelik Programlama (1. basım)" Robert Lafore'nin . Bu kitapların ötesinde programlama bilgim yok. Bu kitap eski olabilir çünkü 20 yaşında. En son sürüme sahibim, eskiyi kullanıyorum çünkü beğendim, esas olarak sadece C ++ 'da kullanılan OOP'nin temel kavramlarını Lafore'nin kitabının ilk baskısı aracılığıyla inceliyorum.

Lafore'nin kitabı "OOP" un sadece daha büyük ve karmaşık programlar için yararlı olduğunu vurguluyor . Her OOP kitabında (Lafore'nin kitabında da) prosedürel paradigmanın, örneğin işlevlerden kolayca etkilenebilecek küresel veriler gibi hatalara eğilimli olduğu söylenir. Programcının prosedür dillerinde dürüst hatalar yapabileceği söylenir, örneğin verileri yanlışlıkla bozan bir işlev yaparak.

Dürüst olmak gerekirse, bu kitapta verilen açıklamayı anlamadığım için sorumu gönderiyorum: C ++ 'da Nesneye Yönelik Programlama (4. Baskı) Lafore'nin kitabında yazılı olan bu ifadeleri kavramıyorum:

Nesneye yönelik programlama daha önceki programlama yaklaşımlarında sınırlamalar keşfedildiği için geliştirildi .... Programlar gittikçe daha karmaşık ve karmaşık hale geldikçe, yapılandırılmış programlama yaklaşımı bile gerginlik belirtileri göstermeye başlar ... .... bu başarısızlıklar, prosedürel paradigmanın kendisinde zayıflıklar olduğunu ortaya koymaktadır. Yapısal programlama yaklaşımı ne kadar iyi uygulanırsa uygulansın, büyük programlar aşırı derecede karmaşık hale gelir .... ... İlgili iki sorun vardır. İlk olarak, fonksiyonların global verilere sınırsız erişimi vardır. İkincisi, yordamsal paradigmanın temeli olan ilişkisiz işlevler ve veriler, gerçek dünyanın zayıf bir modelini sağlar ...

Jeff Kent'in "dismystified C ++" kitabını inceledim, bu kitabı çok beğendim, bu kitapta çoğunlukla prosedürel programlama açıklandı. Prosedürel (yapılandırılmış) programlamanın neden zayıf olduğunu anlamıyorum!

Lafore'nin kitabı konsepti bazı güzel örneklerle çok güzel açıklıyor. Ayrıca Lafore'nin kitabının OOP'un prosedürel programlamadan daha iyi olduğunu okuyarak bir sezgi kavradım, ancak pratikte prosedürel programlamanın OOP'tan ne kadar zayıf olduğunu merak ediyorum.

Prosedürel programlamada karşılaşılabilecek pratik sorunların neler olduğunu, OOP'un programlamayı nasıl kolaylaştıracağını kendime görmek istiyorum. Sanırım cevabımı sadece Lafore'nin kitabını düşünerek okuyacağım ama kendi gözlerimle prosedür kodundaki problemleri görmek istiyorum, bir programın OOP stil kodunun, aynı program prosedürel paradigma kullanılarak yazılacaktı.

OOP birçok özelliği vardır ve birisinin bana tüm bu özelliklerin nasıl yordamsal tarzda kod yazarak ortaya çıkacak hataları kaldırır açıklamak mümkün olmadığını anlıyorum.

Benim sorum budur:

OOP prosedürel programlamanın hangi sınırlamalarına işaret ediyor ve uygulamada bu sınırlamaları nasıl etkili bir şekilde ortadan kaldırıyor?

Özellikle, prosedürel paradigma kullanılarak tasarlanması zor ancak OOP kullanılarak kolayca tasarlanan programlara örnekler var mı?

Not: Çapraz yayın tarihi: /programming//q/22510004/3429430


3
Prosedürel programlama ile nesne yönelimli programlama arasındaki fark bir dereceye kadar sunum ve vurgu meselesidir. Kendilerini nesne yönelimli olarak tanıtan çoğu dil de prosedüreldir - terimler dilin farklı yönlerine bakar.
Gilles 'SO- kötü olmayı bırak'

2
Soruyu şimdi yeniden açtım; bunun nasıl gittiğini görelim. OOP sunan herhangi bir tedavinin kutsal kâse olduğunu, programlama dillerinin tüm problemlerini çözdüğünü aklınızda bulundurun. Artıları ve eksileri vardır. Profesyonelleri soruyorsunuz ve bu adil bir soru; daha fazlasını beklemeyin.
Raphael

OOP'suz (modern) bir masaüstü GUI tasarlama düşüncesi ve üzerinde büyüyen bazı teknikler (örneğin olay / dinleyici deseni) beni korkutuyor. Yine de, yapılamayacağı anlamına gelmez (kesinlikle olabilir ). Ayrıca, işyerinde PP'nin başarısızlığını görmek istiyorsanız, PHP'ye bakın ve API'yi, örneğin Ruby ile karşılaştırın.
Raphael

1
Ayrıca çok gerçek OOP olduğunu "yapılandırılmış programlama yaklaşımı nasıl uygulandığını iyi olursa olsun, büyük programlar ... aşırı karmaşık hale" ama temelde iyi karmaşıklığı yönetmek yapar geliştiriciler tarafından öngörülen şekilde uygulanırsa ... ve yapar büyük ölçüde daha iyi / daha keskin kapsam sınırları / kısıtlamaları yoluyla yani bir çeşit bölümlendirme sistemi ... aka APIE: Soyutlama, Çok Biçimlilik, Kalıtım, Kapsülleme
vzn

Yanıtlar:


9

Yordamsal bir dilde, arayanın bir modülü desteklenen bir biçimde kullandığını kanıtlamak için gereken kısıtlamaları mutlaka ifade edemezsiniz. Derleyici tarafından kontrol edilebilir bir kısıtlamanın yokluğunda, dokümantasyon yazmanız ve takip edildiğini ummanız ve amaçlanan kullanımları göstermek için birim testleri kullanmanız gerekir.

Türleri Bildirmek en belirgin bildirim kısıtlamasıdır (yani: "x'in bir kayan nokta olduğunu kanıtlayın"). Veri mutasyonlarını, bu veriler için tasarlandığı bilinen bir işlevden geçmeye zorlamak başka bir şeydir. Protokol uygulaması (yöntem çağırma sırası) kısmen desteklenen başka bir kısıtlamadır: "yapıcı -> diğer yöntemler * -> yıkıcı".

Derleyici kalıbı bildiğinde gerçek bir fayda (ve birkaç dezavantaj) vardır. Prosedürel bir dilden veri kapsülleme taklit ettiğinizde, polimorfik tiplerle statik yazma biraz sorun yaratır. Örneğin:

x1 tipi x'in bir alt tipidir, t1 t'nin bir alt tipidir

Bu, f ve g yöntemleriyle bir t türüne ve aynı şekilde bir alt sınıf t1'e sahip olmak için verileri yordamsal bir dilde kapsüllemenin bir yoludur:

t_f (t, x, y, z, ...), t_g (t, x, y, ...) t1_f (t1, x, y, z, ...)

Bu kodu olduğu gibi kullanmak için, çağıracağınız f türüne karar vermeden önce bir tür kontrolü yapmanız ve t türünü açmanız gerekir. Etrafında şöyle çalışabilirsiniz:

t {d: veri f: işlev g: işlev} yazın

Bunun yerine, tf (x, y, z) işlevini çağırırsınız; burada yöntemi bulmak için bir typecheck ve switch artık yalnızca her örnek deposu yöntemi işaretçisi açıkça belirtilir. Şimdi, tip başına çok sayıda fonksiyonunuz varsa, bu savurgan bir temsildir. Daha sonra, t, tüm üye işlevlerini içeren bir m değişkenine işaret etmek gibi başka bir strateji kullanabilirsiniz. Bu özellik dilin bir parçasıysa, derleyicinin bu kalıbın verimli bir temsilini yapmakla nasıl başa çıkacağını anlamasına izin verebilirsiniz.

Ancak veri kapsülleme, değişebilir durumun kötü olduğunun farkındadır. Nesneye yönelik çözüm, onu yöntemlerin arkasına saklamaktır. İdeal olarak, bir nesnedeki tüm yöntemlerin iyi tanımlanmış bir çağrı sırası vardır (yani: yapıcı -> açık -> [okuma | yazma] -> kapat -> imha); buna bazen 'protokol' denir (araştırma: "Microsoft Singularity"). Ancak, yapı ve yıkımın ötesinde, bu gereksinimler genellikle tip sisteminin bir parçası değildir - veya iyi belgelenmiştir. Bu anlamda, nesneler, yöntem çağrılarıyla geçirilen durum makinelerinin eşzamanlı örnekleridir; böylece birden fazla örneğiniz olabilir ve bunları rastgele bir araya getirilmiş şekilde kullanabilirsiniz.

Ancak, değişken paylaşılabilir durumun kötü olduğunun farkına varıldığında, nesne veri yapısının, birçok nesnenin referans aldığı değişebilir bir durum olduğu için nesne yöneliminin bir eşzamanlılık sorunu yaratabileceği not edilebilir. Nesne yönelimli dillerin çoğu arayanın iş parçacığında yürütülür, yani yöntem çağrısında ırk koşulları vardır; işlev çağrılarının atomik olmayan dizilerinde bırakalım. Alternatif olarak, her nesne bir kuyrukta zaman uyumsuz mesajlar alabilir ve hepsine nesnenin iş parçacığında (özel yöntemleriyle) hizmet verebilir ve arayanlara mesaj göndererek yanıt verebilir.

Java yöntem çağrılarını çok iş parçacıklı bir bağlamda, birbirleriyle ileti gönderen (yalnızca değişmeyen değerleri referans alan) işlemlerle karşılaştırın.

Paralellik ile birlikte Kısıtlanmamış Nesne Yönelimi, kilitleme nedeniyle bir sorundur. Software Transactional Memory'den (yani: veritabanında olduğu gibi bellek nesnesindeki ACID işlemleri) "iletişim kurarak (değiştirilemez veriler)" (işlevsel programlama hibrid) yaklaşımını paylaşmaya kadar değişen teknikler vardır.

Kanımca, Nesne Yönelimi literatürü FAR'ı kalıtım üzerine çok fazla ve protokole yeterli değil (kontrol edilebilir yöntem çağırma sırası, önkoşullar, postkoşullar, vb.). Bir nesnenin tükettiği girdi genellikle bir tür olarak ifade edilebilen iyi tanımlanmış bir dilbilgisine sahip olmalıdır.


OO dillerinde, derleyicinin yöntemlerin belirtilen sırayla kullanılıp kullanılmadığını veya modüllerin kullanımıyla ilgili diğer kısıtlamaları kontrol edebileceğini mi söylüyorsunuz? Neden "veri kapsülleme [...] değişebilir durumun kötü olduğunun farkında"? Çok biçimlilikten bahsederken, bir OO dili kullandığınızı mı düşünüyorsunuz?
babou

OO'da en önemli özellik, tüm erişimlerin yöntemlerden geçtiğini kanıtlamak için veri yapısını gizleyebilmektir (yani: referansların bu şekilde olmasını gerektirir. X). Statik olarak yazılmış bir OO dilinde, daha da fazla kısıtlama (türlere göre) beyan ediyorsunuz. Yöntem siparişi ile ilgili not sadece OO'nun yapıcıyı ilk çağırmayı ve yıkıcıyı son çağırmayı zorladığını söylüyor; bu, kötü çağrı emirlerini yapısal olarak yasaklamanın ilk adımıdır. Kolay kanıtlar dil tasarımında önemli bir hedeftir.
Rob

8

Prosedürel / fonksiyonel programlama, Turing argümanlarına (dilimin Turing gücü var ve başka bir şey yapabilecek her şeyi yapabilir) girmeden bile OOP'tan daha zayıf değildir, ki bu çok fazla bir şey ifade etmez. Aslında, nesne yönelimli teknikler ilk olarak yerleşik olmayan dillerde denenmiştir. Bu anlamda OO programlama yalnızca belirli bir prosedürel programlama stilidir . Ancak , programın anlaşılabilirliği ve bakımı için gerekli olan modülerlik, soyutlama ve bilgi gizleme gibi belirli disiplinlerin uygulanmasına yardımcı olur .

Bazı programlama paradigmaları, teorik hesaplama vizyonundan evrilir. Lisp gibi bir dil lambda hesabı ve dillerin meta-daireselliği fikrinden evrimleşmiştir (doğal dilde refleksiviteye benzer). Korna hükümleri Prolog ve kısıt programlama programlıydı. Algol ailesi ayrıca yerleşik yansıma olmadan lambda kalkülüsüne borçludur.

Lisp, çift genetik mirasına kadar izlenebilir olan birçok programlama dili yeniliğinin test edilmiş hali olduğu için ilginç bir örnektir.

Ancak diller genellikle yeni isimler altında gelişir. Evrimin önemli bir faktörü programlama uygulamasıdır. Kullanıcılar, okunabilirlik, sürdürülebilirlik, doğruluk olasılığı gibi programların özelliklerini geliştiren programlama uygulamalarını tanımlar. Daha sonra, programların kalitesini artırmak için bu uygulamaları destekleyecek ve bazen de uygulayacak olan dil özelliklerini veya kısıtlamalarını eklemeye çalışırlar.

Bunun anlamı, bu uygulamaların eski programlama dilinde zaten mümkün olmasıdır, ancak bunları kullanmak için anlayış ve disiplin gerekir. Bunları belirli sözdizimiyle birincil kavramlar olarak yeni dillere dahil etmek, bu uygulamaların, özellikle daha az karmaşık kullanıcılar (yani büyük çoğunluk) için kullanımını ve kolayca anlaşılmasını sağlar. Ayrıca, sofistike kullanıcılar için hayatı biraz daha kolaylaştırır.

Bir şekilde, bir programa bir alt programın / fonksiyonun / prosedürün ne olduğunu dil tasarlamaktır. Yararlı kavram belirlendikten sonra, bir ad (muhtemelen) ve bir sözdizimi verilir, böylece bu dil ile geliştirilen tüm programlarda kolayca kullanılabilir. Ve başarılı olduğunda, gelecekteki dillere de dahil edilecektir.

Örnek: nesne yönlendirmesini yeniden oluşturma

Şimdi bunu bir örnek üzerinde göstermeye çalışıyorum (ki bu kesinlikle daha da cilalanabilir, zaman verildi). Örneğin amacı, nesne yönelimli bir programın muhtemelen programlama ve sürdürülebilirlik pahasına prosedürel programlama tarzında yazılabileceğini göstermek değildir. OO tesisleri olmayan bazı dillerin , modülerlik, soyutlama ve bilgi gizleme de dahil olmak üzere program organizasyonu ile ilgili niteliklerinden yararlanmak için Nesne Yönelimini etkili bir şekilde taklit etmek için aslında daha yüksek dereceli işlevler ve veri yapısı kullanabileceğini göstermeye çalışacağım. .

Dediğim gibi Lisp, OO paradigması da dahil olmak üzere birçok dil gelişiminin test edildi (ilk OO dili olarak kabul edilebilecek şey Algol ailesinde Simula 67 idi). Lisp çok basittir ve temel yorumlayıcısının kodu bir sayfadan daha azdır. Ancak Lisp'de OO programlama yapabilirsiniz. Tek ihtiyacınız olan daha üst düzey işlevler.

Sunumu basitleştirmek için ezoterik Lisp sözdizimini değil, sözde kodu kullanacağım. Ve basit bir temel problemi ele alacağım: bilgi gizleme ve modülerlik . Kullanıcının uygulamaya erişmesini (çoğunu) engellerken bir nesne sınıfı tanımlama.

Vektör ekleme, vektör boyutu ve paralellik gibi yöntemler ile 2 boyutlu vektörleri temsil eden vector adında bir sınıf oluşturmak istediğimizi varsayalım.

function vectorrec () {  
  function createrec(x,y) { return [x,y] }  
  function xcoordrec(v) { return v[0] }  
  function ycoordrec(v) { return v[1] }  
  function plusrec (u,v) { return [u[0]+v[0], u[1]+v[1]] }  
  function sizerec(v) { return sqrt(v[0]*v[0]+v[1]*v[1]) }  
  function parallelrec(u,v) { return u[0]*v[1]==u[1]*v[0]] }  
  return [createrec, xcoordrec, ycoordrec, plusrec, sizerec, parallelrec]  
  }  

Sonra yaratılan vektörü kullanılacak gerçek fonksiyon isimlerine atayabilirim.

[vektör, xcoord, ycoord, vplus, vsize, vparallel] = vectorclass ()

Neden bu kadar karmaşık? Çünkü fonksiyon vektörüsünde aracı yapıları tanımlayabiliyorum ki, modülerliği korumak için programın geri kalanında görünmek istemiyorum.

Kutupsal koordinatlarda başka bir koleksiyon yapabiliriz

function vectorpol () {  
  ...  
  function pluspol (u,v) { ... }  
  function sizepol (v) { return v[0] }  
  ...  
  return [createpol, xcoordpol, ycoordpol, pluspol, sizepol, parallelpol]  
  }  

Ama kayıtsızca her iki uygulamayı da kullanmak isteyebilirim. Bunu yapmanın bir yolu, tüm değerlere bir yazım bileşeni eklemektir ve aynı ortamda yukarıdaki tüm işlevleri tanımlamaktır: Daha sonra, döndürülen işlevlerin her birini tanımlayabilir, böylece önce koordinat türünü test eder, ardından belirli işlevi uygular onun için.

function vector () {  
    ...  
    function plusrec (u,v) { ... }  
    ...  
    function pluspol (u,v) { ... }  
    ...  
    function plus (u,v) { if u[2]='rec' and v[2]='rec'  
                            then return plusrec (u,v) ... }  

    return [ ..., plus, ...]  
    }

Ne kazandım: belirli işlevler görünmez kalır (yerel tanımlayıcıların kapsamı nedeniyle) ve programın geri kalanı yalnızca vectorclass çağrısı tarafından döndürülen en soyut olanları kullanabilir.

Bir itiraz, programdaki soyut işlevlerin her birini doğrudan tanımlayabilmem ve koordinat türüne bağlı işlevlerin tanımının içinde bırakabilmemdir. Sonra da gizlenirdi. Bu doğrudur, ancak daha sonra her bir koordinat türü için kod, programa yayılmış küçük parçalar halinde kesilir, bu da daha az tekrarlanabilir ve bakımı yapılabilir.

Aslında, onlara bir isim vermek zorunda değilim ve sadece tür ve işlev adını temsil eden bir dize ile dizinlenmiş bir veri yapısında anonim fonksiyonel değerleri tutabilir. Fonksiyon vektörüne lokal olan bu yapı, programın geri kalanından görünmez olacaktır.

Kullanımı basitleştirmek için, bir işlev listesi döndürmek yerine, argüman olarak açıkça yazılan bir değer ve dize alarak tek bir işlevi döndürebilir ve işlevi uygun tür ve adla uygulayabilirim. Bu, bir OO sınıfı için bir yöntem çağırmaya çok benziyor.

Burada, nesne yönelimli bir tesisin yeniden inşasında duracağım.

Yapmaya çalıştığım şey, kalıtım ve diğer benzeri özellikler de dahil olmak üzere yeterince güçlü bir dilde kullanılabilir nesne yönelimi oluşturmanın çok zor olmadığını göstermektir. Tercümanın metacirkülaritesi yardımcı olabilir, ancak çoğunlukla ihmal edilemez olmaktan çok sözdizimsel düzeyde.

Nesne yöneliminin ilk kullanıcıları kavramları bu şekilde denedi. Ve bu genellikle programlama dillerindeki birçok iyileştirme için geçerlidir. Tabii ki, teorik analizin de bir rolü vardır ve bu kavramların anlaşılmasına veya geliştirilmesine yardımcı olmuştur.

Ancak OO özelliği olmayan dillerin bazı projelerde başarısızlığa mahkum olduğu fikri basitçe garanti edilmez. Gerekirse, bu özelliklerin uygulanmasını oldukça etkili bir şekilde taklit edebilirler. Pek çok dil, yerleşik olmasa bile nesne yönelimini oldukça etkili bir şekilde yapmak için sözdizimsel ve anlamsal güce sahiptir. Ve bu bir Turing argümanından daha fazlası.

OOP, diğer dillerin sınırlamalarını ele almaz, ancak daha iyi program yazmaya yardımcı olan programlama yöntemlerini destekler veya uygular , böylece daha az deneyimli kullanıcıların bu destek olmadan kullandığı ve geliştirdiği daha gelişmiş programcıların iyi uygulamalarını takip etmesine yardımcı olur.

Tüm bunları anlamak için iyi bir kitabın Abelson & Sussman olabileceğini düşünüyorum : bilgisayar programlarının yapısı ve yorumu .


8

Sanırım biraz tarih düzenli.

1960'ların ortasından 1970'lerin ortasına kadar olan dönem bugün "yazılım krizi" olarak biliniyor. 1972'deki Turing ödül dersinde Dijkstra'dan daha iyi koyamam:

Yazılım krizinin en büyük nedeni, makinelerin birkaç büyüklükte daha güçlü hale gelmesidir! Açıkça söylemek gerekirse: makine olmadığı sürece programlama hiç sorun değildi; birkaç zayıf bilgisayarımız olduğunda, programlama hafif bir problem haline geldi ve şimdi devasa bilgisayarlarımız var, programlama da aynı derecede devasa bir problem haline geldi.

Bu, ilk 32 bit bilgisayarların, ilk gerçek çok işlemcilerin ve ilk gömülü bilgisayarların zamanıydı ve araştırmacılar için bunların gelecekte programlama için önemli olacağı açıktı. Tarihte, müşteri talebinin programcı kapasitesini ilk kez aştığı bir zamandı.

Şaşırtıcı olmayan bir şekilde, programlama araştırmasında oldukça verimli bir zamandı. 1960'ların ortalarından önce, LISP ve AP / L vardı, ama "ana" diller temel olarak prosedüreldi: FORTRAN, ALGOL, COBOL, PL / I vb. 1960'ların ortalarından 1970'lerin ortalarına kadar Logo, Pascal, C, Forth, Smalltalk, Prolog, ML ve Modula var ve bu SQL ve öncülleri gibi DSL'leri saymıyor.

Programlama dillerini uygulamak için birçok kilit tekniğin geliştirildiği de tarihte bir zamandı . Bu dönemde, LR ayrıştırma, veri akışı analizi, ortak alt ifade eleme ve bazı derleyici problemlerinin (örneğin kayıt tahsisi) NP zor olduğunu ve bunları bu şekilde ele almaya çalıştığımızın ilk tanınmasını aldık.

Bu, OOP'nin ortaya çıktığı bağlamdır. 1970'lerin başında, OOP'un pratikte hangi sorunları çözdüğü sorusuna cevap veriyoruz, ilk cevap, tarihin o döneminde programcıların karşılaştığı birçok problemi (hem çağdaş hem de beklenen) çözdüğü ortaya çıktı. Ancak bu, OO'nun ana akım haline geldiği zaman değil. Yakında buna ulaşacağız.

Alan Kay "nesne yönelimli" terimini ortaya attığında, aklındaki resim, yazılım sistemlerinin biyolojik sistem gibi yapılandırılacağıydı. Kimyasal sinyallere ("mesajlar") benzer bir şey göndererek birbirleriyle etkileşen tek tek hücreler ("nesneler") gibi bir şeyiniz olurdu. Bir hücrenin içine bakamazsınız (ya da en azından yapamazsınız); onunla yalnızca sinyal yollarından etkileşime girersiniz. Ayrıca, gerekirse her bir hücre türünden birden fazlasına sahip olabilirsiniz.

Burada birkaç önemli temanın olduğunu görebilirsiniz: iyi tanımlanmış bir sinyal protokolü kavramı (modern terminolojide, bir arayüzde), uygulamayı dışarıdan gizleme kavramı (modern terminolojide, mahremiyette) ve aynı türden aynı anda asılı olan birden fazla "nesneye" sahip olmak (modern terminoloji, örnekleme).

Dikkat edebileceğiniz bir şey eksik ve bu kalıtım, ve bunun bir nedeni var.

Nesneye yönelik programlama soyut bir kavramdır ve soyut kavram farklı programlama dillerinde farklı şekillerde uygulanabilir. Örneğin, bir "yöntemin" soyut kavramı, işlev işaretçileri kullanılarak C'de ve üye işlevleri kullanılarak C ++ 'da ve Smalltalk'ta (Smalltalk soyut kavramı hemen hemen doğrudan uyguladığı için şaşırtıcı olması gerekir) yöntemler kullanılarak uygulanabilir. Bu, insanların (neredeyse) herhangi bir dilde "neredeyse" OOP yapabileceğinizi işaret ettiklerinde kastedilen şeydir.

Kalıtım ise somut bir programlama dili özelliğidir. Kalıtım OOP sistemlerinin uygulanması için yararlı olabilir. Ya da en azından 1990'ların başına kadar böyleydi.

1980'lerin ortasından 1990'ların ortasına kadar geçen süre, tarihte olayların değiştiği bir zamandı. Bu süre zarfında, ucuz, her yerde bulunan 32 bit bilgisayarın yükselişini yaşadık, böylece işletmeler ve birçok ev, her masaya günün en düşük ana çerçeveleri kadar güçlü bir bilgisayar yerleştirmeyi göze alabiliyordu. Aynı zamanda modern GUI'nin ve ağa bağlı işletim sisteminin yükseliş dönemiydi.

Bu bağlamda Nesneye Dayalı Analiz ve Tasarım ortaya çıktı.

"Üç Amigos" (Booch, Rumbar ve Jacobson) ve diğerlerinin (örneğin, Shlaer-Mellor yöntemi, sorumluluk odaklı tasarım, vb.) OOAD'ın etkisi anlaşılmaz olamaz. 1990'ların başından bu yana geliştirilen yeni dillerin çoğunun (en azından duyduğunların çoğunun) Simula tarzı nesnelere sahip olmasının nedeni budur.

1990'ların sorunuzun cevabı, alan adı odaklı analiz ve tasarım metodolojisi için en iyi (o sırada) çözümü desteklemesi.

O zamandan beri, bir çekiçimiz olduğu için, OOP'u o zamandan beri ortaya çıkan her probleme uyguladık. OOAD ve kullandığı nesne modeli, çevik ve test odaklı geliştirme, küme ve diğer dağıtılmış sistemleri vb. Teşvik etti ve etkinleştirdi.

Modern GUI'ler ve son 20 yılda tasarlanan herhangi bir işletim sistemi, hizmetlerini nesne olarak sunma eğilimindedir, bu nedenle yeni pratik programlama dilleri en azından bugün kullandığımız sistemlere bağlanma yoluna ihtiyaç duyar.

Modern cevap şudur: Modern dünyayla arayüz oluşturma sorununu çözer. Modern dünya, 1880 dünyasının buhar üzerine inşa edildiği sebeple OOP üzerine inşa edilmiştir: anlıyoruz, kontrol edebiliyoruz ve işi yeterince iyi yapıyor.

Bu, araştırmanın burada durduğu anlamına gelmiyor elbette, ancak herhangi bir yeni teknolojinin sınırlayıcı bir durum olarak OO'ya ihtiyaç duyacağını güçlü bir şekilde gösteriyor. OO olmanıza gerek yok, ancak temel olarak onunla bağdaşmazsınız.


Ana makaleye koymak istemediğim bir yanı, WIMP GUI'leri ve OOP'un son derece doğal bir uyum olduğu görünüyor. Derin kalıtım hiyerarşileri hakkında birçok kötü şey söylenebilir, ancak bu bir tür mantıklı göründüğü bir durumdur (muhtemelen SADECE durum).
Takma isim

1
OOP ilk olarak Simula-67'de (simülasyon), işletim sistemlerinin dahili organizasyonunda ortaya çıktı (Unix'teki "cihaz sınıfı" fikri, sürücülerin miras aldığı bir sınıftır). Parnas'ın 'modülleri sistemlerinin çürüyen kullanılacak kriterler Açık' , CACM 15:12 (1972), s. 1052-1058, Wirth'in Modula yetmişli dili, 'veri tipleri' veya bu şekilde tüm ön-maddeleridir diğer.
vonbrand

Hepsi bu, ama OOP'nin 70'lerin ortasına kadar bir "prosedürel programlama sorununa çözüm" olarak görülmediğini düşünüyorum. "OOP" tanımını yapmak oldukça zordur. Alan Kay'ın bu terimi orijinal kullanımı Simula'nın modeliyle aynı fikirde değil ve maalesef dünya Simula'nın modelinde standart hale geldi. Bazı nesne modellerinde Curry-Howard benzeri bir yorum vardır, ancak Simula'nın yoktur. Stepanov, mirasın sağlam olmadığını belirttiğinde muhtemelen doğruydu.
Müstear

6

Gerçekten yok. OOP kesinlikle bir problemi çözmüyor; Nesne yönelimli olmayan bir sistemle yapamayacağınız nesne yönelimli bir sistemle yapabileceğiniz hiçbir şey yoktur, gerçekten de Turing makinesiyle yapılamayan hiçbir şey yapamazsınız. Her şey sonunda makine koduna dönüşür ve ASM kesinlikle nesne yönelimli değildir.

OOP paradigmasının sizin için yaptığı şey, değişkenleri ve işlevleri düzenlemeyi kolaylaştırır ve bunları birlikte daha kolay hareket ettirmenize olanak tanır.

Diyelim ki Python'da bir kart oyunu yazmak istiyorum. Kartları nasıl temsil ederim?

OOP hakkında bir şey bilmiyorsam, bunu şu şekilde yapabilirim:

cards=["1S","2S","3S","4S","5S","6S","7S","8S","9S","10S","JS","QS","KS","1H","2H",...,"10C","JC","QC","KC"]

Muhtemelen bu kartları oluşturmak için sadece elle yazmak yerine bazı kodlar yazardım, ama anladınız. "1S" Maça 1'ini, "JD" ise Elmasların Jackini temsil eder, vb. Joker için de bir koda ihtiyacım var, ama şimdilik Joker yokmuş gibi davranacağız.

Şimdi güverteyi karıştırmak istediğimde, sadece listeyi karıştırmam lazım. Sonra, destenin üstünden bir kart almak için, listeden en üstteki girişi açıp dizeyi verdim. Basit.

Şimdi oyuncuya göstermek için hangi kartla çalıştığımı bulmak istersem, böyle bir işleve ihtiyacım olacak:

def card_code_to_name(code):
    suit=code[1]

    if suit=="S":
        suit="Spades"
    elif suit=="H"
        suit="Hearts"
    elif suit=="D"
        suit="Diamonds"
    elif suit=="C"
        suit="Clubs"

    value=code[0]

    if value=="J":
        value="Jack"
    elif value="Q":
        value="Queen"
    elif value="K"
        value="King"

    return value+" of "+suit

Biraz büyük, uzun ve verimsiz, ama işe yarıyor (ve çok unpythonic, ama buradaki noktanın yanında).

Peki ya kartların ekranda hareket edebilmesini istiyorsam? Konumlarını bir şekilde saklamam gerekiyor. Kart kodlarının sonuna ekleyebilirdim, ama bu biraz hantal olabilir. Bunun yerine, her kartın nerede olduğuna dair başka bir liste yapalım:

cardpositions=( (1,1), (2,1), (3,1) ...)

Daha sonra kodumu yazıyorum, böylece listedeki her kartın konumunun dizini destedeki kartın diziniyle aynı olur.

Ya da en azından olmalıdır. Bir hata yapmadıkça. Hangi çok iyi olabilir, çünkü benim kod bu kurulumu işlemek için oldukça karmaşık olması gerekir. Kartları karıştırmak istediğimde, pozisyonları aynı sırada karıştırmam gerekiyor. Bir kartı desteden tamamen çıkarırsam ne olur? Ben de pozisyonunu çıkarmam ve başka bir yere koymam gerekecek.

Peki ya kartlar hakkında daha fazla bilgi depolamak istersem? Her kartın çevrilmiş olup olmadığını saklamak istersem ne olur? Bir tür fizik motoru istiyor ve kartların hızını da bilmem gerekirse ne olur? Her kart için grafikleri saklamak için tamamen başka bir listeye ihtiyacım olacak! Ve tüm bu veri noktaları için, hepsini düzgün bir şekilde organize tutmak için ayrı bir koda ihtiyacım olacak, böylece her kart bir şekilde tüm verileriyle eşleşiyor!

Şimdi bunu OOP yolu deneyelim.

Bir kod listesi yerine bir Card sınıfı tanımlayalım ve ondan Card nesnelerinin bir listesini oluşturalım.

class Card:

    def __init__(self,value,suit,pos,sprite,flipped=False):
        self.value=value
        self.suit=suit
        self.pos=pos
        self.sprite=sprite
        self.flipped=flipped

    def __str__(self):
        return self.value+" of "+self.suit

    def flip(self):
        if self.flipped:
            self.flipped=False
            self.sprite=load_card_sprite(value, suit)
        else:
            self.flipped=True
            self.sprite=load_card_back_sprite()

deck=[]
for suit in ("Spades","Hearts","Diamonds","Clubs"):
    for value in ("1","2","3","4","5","6","7","8","9","10","Jack","Queen","King"):
        sprite=load_card_sprite(value, suit)
        thecard=Card(value,suit,(0,0),sprite)
        deck.append(thecard)

Şimdi, aniden, her şey çok daha basit. Kartı taşımak istersem, destede nerede olduğunu bulmak zorunda değilim, daha sonra konumunu konum dizisinin dışına almak için kullanın. Sadece söylemeliyimthecard.pos=newpos . Kartı ana deste listesinden çıkardığımda, diğer tüm verileri saklamak için yeni bir liste yapmak zorunda değilim; kart nesnesi hareket ettiğinde, tüm özellikleri onunla birlikte taşınır. Ve onun çevirdiğinde farklı davranan bir kart istiyorsanız, bu kartları algılar ve bu farklı davranış yapar, böylece benim ana kod saygısız işlevini değiştirmek zorunda değilsiniz; Sadece Kart alt sınıf ve alt sınıf flip () işlevini değiştirmek zorunda.

Ama orada yaptığım hiçbir şey OO olmadan yapılamazdı. Sadece nesne yönelimli bir dille, dil sizin için bir şeyleri bir arada tutma işi yapar, yani hata yapma şansınız çok daha azdır ve kodunuz daha kısa ve okunması ve yazılması daha kolaydır.

Ya da daha fazlasını özetlemek gerekirse, OO, bir soyutlama perdesinin arkasındaki verileri işlemenin ortak karmaşıklıklarını gizleyerek daha karmaşık programlarla aynı işi yapan daha basit görünen programlar yazmanıza izin verir.


1
Eğer OOP 'dan aldığınız tek şey "bellek yönetimi" ise o zaman çok iyi anladığınızı sanmıyorum. Orada tüm tasarım felsefesi ve "tasarım gereği" cömert bir şişe var! Ayrıca, bellek yönetimi, nesne ihtiyacı daha belirgin hale gelmesine rağmen, kesinlikle nesne yöneliminin doğasında olan bir şey değildir (C ++?).
Raphael

Tabii, ama bu tek cümlelik versiyon. Bu terimi de oldukça standart olmayan bir şekilde kullandım. Belki de "bilgi yönetimi" demek "bellek yönetimi" nden daha iyi olur.
Schilcote

Bir işlevin bir şeye işaretçi almasına izin verecek OOP olmayan diller ve ayrıca ilk parametresi aynı türden bir işaretçi olan bir işleve bir işaretçi var mı ve derleyicinin işlevin uygun olduğunu doğrulamasını sağlayan herhangi bir dil var mı? geçilen işaretçi için?
supercat

3

Seri portlar, ağ portları ve sunucular arasındaki cihazları, seri portları ve iletişim paketlerini yönetmek için birkaç yıl boyunca gömülü C yazdıktan sonra; Kendimi, sınırlı prosedürsel programlama deneyimine sahip eğitimli bir elektrik mühendisi olarak buldum, daha sonra fark ettiğim şeyde ortaya çıkan donanımdan kendi soyutlamalarımı uydurdum, normal insanların 'Nesneye Yönelik Programlama' dediği şeydi.

Sunucu tarafına geçtiğimde, bellekte her aygıtın nesne temsilini ayarlayan bir fabrikaya maruz kaldım. Kelimeleri ya da ilk başta neler olduğunu anlamadım - sadece böyle bir dosyaya gittiğimi ve böyle yazdığımı biliyordum. Daha sonra kendimi tekrar buldum, sonunda OOP'un değerini fark ettim.

Ben şahsen, nesne yönelimini öğretmenin tek yolu olduğunu düşünüyorum. Birinci sınıfım OOP (Java) dersine giriş yaptım ve tamamen başımın üstündeydi. OOP açıklamaları temel alınmıştırYavru kedi-> kedi-> memeli-> canlı-> şey veya yaprak-> şube-> ağaç-> bahçe sınıflandırması , benim düşünceme göre, kesinlikle saçma metodolojilerdir, çünkü hiç kimse bunları çözmeye çalışmayacak sorunları, eğer hatta onları sorunları diyebiliriz ...

Bence sorunuza daha az mutlak terimlerle bakarsanız daha kolay cevap verirsiniz - 'neyi çözer' değil, daha çok 'işte bir sorun ve işte bunu nasıl kolaylaştırıyor' açısından. Belirli seri bağlantı noktaları durumumda, seri bağlantı noktalarını statik olarak açan ve kapatan kod ekleyen ve kaldıran bir sürü derleme zamanı #ifdefs vardı. Bağlantı noktası açık işlevleri her yerde çağrıldı ve sahip olduğumuz 100k OS kod satırının herhangi bir yerinde bulunabilirdi ve IDE, tanımlanmayanı grileştirmedi - bunu manuel olarak izlemelisiniz ve kafanda taşı. Kaçınılmaz olarak olarak, diğer tarafta cihazlarını bekleyen belirli bir seri bağlantı noktasını açmaya çalışan birkaç göreviniz ve daha sonra yazdığınız kodun hiçbiri işe yaramaz ve nedenini anlayamazsınız.

Soyutlama, hala C'de olmasına rağmen, her seri port için bir diziye sahip olduğumuz ve [seri portlarda DMA eşdeğeri] yerine bir seri port 'sınıfı' (yani, sadece bir yapı veri tipi) idi. "OpenSerialPortA" "SetBaudRate" vb. İşlevler, doğrudan donanımdan görevden çağrıldı, tüm iletişim parametrelerini (baud, parite vb.) Geçirdiğiniz bir yardımcı işlev olarak adlandırdık . bağlantı noktası zaten açılmıştı - öyleyse, hangi görevi, hata ayıklama printf olarak söyleyeceğini, böylece devre dışı bırakmanız gereken kod bölümüne hemen atlayabilmeniz için - ve değilse, ayarlamaya devam etti tüm parametreleri HAL montaj işlevleri aracılığıyla ve nihayet bağlantı noktasını açtı.

Tabii ki, OOP için de tehlikeler var. Sonunda bu kod tabanını temizlediğimde ve her şeyi düzgün ve temiz yaptığımda - bu ürün hattı için yeni sürücüler yazmak sonunda hesaplanabilir, öngörülebilir bir bilime düştü, yöneticim ürünü özellikle EOL'd.Çünkü ihtiyaç duyduğu daha az proje oldu ve sınırda çıkarılabilir orta yönetimdi. Benden çok şey çıkardı / çok cesaret kırıcı buldum, bu yüzden işimi bıraktım. LOL.


1
Selam! Bu, sorunun cevabından ziyade kişisel bir tarihe benziyor. Örneğinizden, nesne yönelimli bir tarzda bazı korkunç kodları yeniden yazdığınızı görüyorum, bu da onu daha iyi hale getirdi. Ancak, geliştirmenin nesne yönelimi ile ilgisi olup olmadığı veya bunun o zamana kadar daha yetkin bir programcı olmanızdan kaynaklanmaması belirsizdir. Örneğin, sorununuzu iyi bir anlaşma kod willy-nilly yeri hakkında dağılmış gibi görünüyor. Bu, hiçbir nesne olmadan prosedürel bir kütüphane yazarak çözülebilirdi.
David Richerby

2
@DavidRicherby prosedürel kütüphaneye sahiptik, ama bunu reddettik, sadece kod her yerde olmakla ilgili değildi. Mesele şu ki bunu geriye doğru yaptık. Kimse hiçbir şeyi OOP yapmaya çalışmadı, sadece doğal olarak oldu.
pa

@DavidRicherby, aynı şeyden bahsettiğimizden emin olabilmem için prosedürel kütüphane uygulamalarına örnek verebilir misiniz?
Eylül'ü

2
Cevabınız ve +1 için teşekkürler. Uzun zaman önce başka bir deneyimli programcı, OOP'nin projesini nasıl daha güvenilir hale getirdiğini paylaştı.devshed.com/programming- 42/ … Sanırım OOP, prosedürel yaklaşımda bazı sorunlarla karşılaşmış olabilecek bazı profesyoneller tarafından çok akıllı bir şekilde tasarlandı.
user31782

2

OOP programlamasının, mucitleri ve kullanıcıları da dahil olmak üzere prosedürel programlamaya neyin / nerede bir avantajı olduğuna dair birçok iddia ve niyet vardır. ancak sadece bir teknoloji tasarımcıları tarafından belirli bir amaç için tasarlandığından , bu hedeflerde başarılı olacağını garanti etmez . Bu, OOP kodlama devrimine rağmen hala geçerli olan Brooks ünlü makalesi "Gümüş mermi" ile çıkan yazılım mühendisliği alanında önemli bir anlayıştır . (ayrıca bkz. Gartner Hype Döngüsü yeni teknolojiler için .)

Her ikisini de kullanan pek çok kişi de anekdot deneyiminden görüşlere sahiptir ve bunun bir değeri vardır, ancak birçok bilimsel çalışmada, kendi kendini bildiren analizin yanlış olabileceği bilinmektedir. bu farklılıkların çok az kantitatif analizi var gibi görünüyor ya da varsa, çok fazla alıntı yapılmıyor. kendi alanında merkezi olan bazı konularda yetkili olarak kaç bilgisayar bilimcisi konuşuyor, ancak görüşlerini desteklemek için bilimsel araştırmalar teklif etmiyor ve gerçekte kendi alanlarında geleneksel bilgeliği ( yaygın olsa da ) geçtiklerini fark etmiyorlar .

Bu bir bilim sitesi / forumu olduğundan, burada daha sağlam temeller üzerine sayısız fikir koymak ve gerçek farkı ölçmek için kısa bir girişim . başka çalışmalar da olabilir ve başkalarının duyduklarını söyleyebilir.(zen soru: gerçekten büyük bir fark varsa ve ticari yazılım mühendisliği alanında ve başka yerlerde çok büyük bir çaba varsa, bunu gerçekleştirmek için uygulanmış / yatırım yapılmışsa, bunun bilimsel kanıtlarının gelmesi neden bu kadar zor olmalı? farklılığı kesin olarak ölçen klasik, alıntı yapılan bazı referanslar?)

Bu makale deneysel / nicel / bilimsel analiz kullanmaktadır ve özellikle acemi programcılar tarafından anlaşılmanın bazı durumlarda OOP kodlama yöntemleri ile geliştirildiğini, ancak diğer durumlarda (program boyutlarına göre) sonuçsuz kaldığını desteklemektedir . Bu, OOP üstünlüğünün diğer cevaplarda ve OOP savunucuları tarafından ileri sürülmesiyle ilgili birçok / büyük iddiadan sadece bir tanesidir . çalışma muhtemelen “bilişsel yük / tepegöz” kodlama anlama olarak bilinen psikolojik bir öğeyi ölçüyordu.

  • Yeni başlayan programcılar tarafından nesne yönelimli ve yordamsal programların Bilgisayar ile Etkileşiminde kavranmasının karşılaştırılması . Susan Wiedenbeck, Vennila Ramalingam, Suseela Sarasamma, Cynthia L Corritore (1999)

    Bu makale zihinsel temsiller ve program kavrayışını, nesne yönelimli ve prosedürel tarzdaki acemilerle karşılaştıran iki deney hakkında rapor vermektedir. Denekler, ya nesne yönelimli ya da prosedürel paradigmayı öğreten programlamada ikinci bir kursa kaydolan acemi programcılardı. İlk deney, prosedürel ve nesne yönelimli tarzlarda yazılmış kısa programların zihinsel temsillerini ve kavrayışlarını karşılaştırmıştır. İkinci deney, çalışmayı daha gelişmiş dil özelliklerini içeren daha büyük bir programa genişletti. Kısa programlar için, doğru cevaplanan toplam soru sayısı açısından iki grup arasında anlamlı bir fark yoktu, ancak nesne yönelimli konular, program fonksiyonu hakkındaki soruları yanıtlarken prosedürel konulardan daha üstündü. Bu, işlev bilgilerinin programların zihinsel temsillerinde daha kolay mevcut olduğunu ve nesne yönelimli gösterimin, bireysel sınıf düzeyinde işlevi vurguladığı argümanını desteklediğini göstermektedir. Uzun program için karşılık gelen bir etki bulunamadı. Prosedürel deneklerin kavranması, tüm soru türleri üzerindeki nesne yönelimli deneklerden daha üstündür. Nesneye yönelik konuların daha geniş bir programda soruları cevaplarken yaşadıkları zorluklar, bilgi paylaşımında ve bunlardan çıkarımlarda bulunmada sorunlarla karşılaştıklarını göstermektedir. Bu sonucun, nesne yönelimli stilde yeni başlayanlar için daha uzun bir öğrenme eğrisinin yanı sıra OO stilinin özellikleri ve belirli OO dil gösterimi ile ilgili olabileceğini öneririz.

Ayrıca bakınız:


1
Deneysel çalışmalara saygı duyuyorum. Bununla birlikte, doğru soruları ele aldıklarını belirleme meselesi vardır. Tek bir çalışmanın anlamlı olması için OOP olarak adlandırılabilecek ve onu kullanma yollarında çok fazla değişken vardır, imho. Programlamadaki birçok şey gibi, OOP da uzmanlar tarafından kendi ihtiyaçlarını karşılamak için yaratılmıştır . OOP'un (OP'nin konusu olarak almadığım, daha ziyade prosedürel programlamanın eksikliğini ele alıp almadığının) faydasını tartışırken, bir soru sorabilir: hangi özellik, kim için, hangi amaçla? O zaman sadece saha çalışmaları tamamen anlamlı hale gelir.
babou

1
Anekdot uyarısı: Bir sorun ufacıksa (örneğin yaklaşık 500-1000 satır koduna kadar), OOP deneyimimde hiçbir fark yaratmaz, çok az fark yaratan şeyler hakkında endişelenmek zorunda kalmadan bile engel olabilir. Sorun büyükse ve daha sonra eklenmesi gereken bir tür "değiştirilebilir parçalar" varsa (GUI'deki pencereler, işletim sistemindeki cihazlar, ...) OOP disiplinin sağladığı organizasyon kaçınılmazdır. OOP'yi kesinlikle dil desteği olmadan programlayabilirsiniz (bkz. Örneğin Linux çekirdeği).
vonbrand

1

Dikkatli ol. R. King tarafından klasik olarak "Nesneye Yönelik Kavramlar, Veritabanları ve Uygulamalar" (Kim ve Lochovsky, eds) (ACM, 1989) adlı kitabında "Kedim Nesneye Yöneliktir" i okuyun. "Nesne yönelimli" bir açık kavramdan çok bir vızıltı kelimesi haline geldi.

Ayrıca, tema üzerinde pek çok varyasyon var, ortak noktaları az. Prototip tabanlı diller (kalıtım nesnelerden gelir, böyle sınıflar yoktur) ve sınıf tabanlı diller vardır. Birden fazla mirasa izin veren diller vardır, diğerleri izin vermez. Bazı diller Java'nın arayüzleri gibi bir fikre sahiptir (sulandırılmış çoklu kalıtım biçimi olarak alınabilir). Mixin fikri var. Kalıtım oldukça katı olabilir (C ++ 'da olduğu gibi, bir alt sınıfta elde ettiğiniz şeyi gerçekten değiştiremez) veya çok liberal olarak ele alınabilir (Perl'de alt sınıf neredeyse her şeyi yeniden tanımlayabilir). Bazı diller miras için tek bir köke sahiptir (genellikle Nesne olarak adlandırılır, varsayılan davranışla), diğerleri programcının birden fazla ağaç oluşturmasına izin verir. Bazı diller "her şeyin bir nesne olduğu" konusunda ısrar ederken, diğerleri nesneleri ve nesne olmayanları ele alır, bazılarında (Java gibi) "çoğu nesnedir, ancak buradaki bu türler değildir". Bazı diller nesnelerde devletin sıkı bir şekilde kapsüllenmesinde ısrar eder, diğerleri onu isteğe bağlı yapar (C ++ 'özel, korumalı, genel), diğerlerinde hiç kapsülleme yoktur. Şema gibi bir dile doğru açıdan şaşıyorsanız, OOP'un özel bir çaba harcamadan yerleşik olduğunu görürsünüz (bazı yerel durumları kapsayan işlevleri döndüren işlevleri tanımlayabilir).


0

Özlü olmak için Nesneye Dayalı Programlama, prosedürel programlamada mevcut olan veri güvenliği sorunlarını ele almaktadır. Bu, yalnızca meşru sınıfların verileri devralmasına izin vererek, verileri kapsülleme kavramı kullanılarak yapılır. Erişim değiştiriciler bu hedefe ulaşmayı kolaylaştırır. Umarım yardımcı olur.:)


Prosedürel programlamada mevcut olan veri güvenliği sorunları nelerdir?
user31782

Prosedürel programlamada küresel bir değişkenin kullanımı kısıtlanamaz. Herhangi bir işlev değerini kullanabilir. Ancak OOP'de bir değişkenin kullanımını sadece belirli bir sınıfla ya da sadece onu miras alan sınıflarla kısıtlayabilirim.
manu

Prosedürel programlamada, değişkeni kullanarak global değişkenin kullanımını, belirli işlevlerle, yani global bir veri beyan etmeyerek kısıtlayabiliriz.
user31782

Eğer küresel olarak beyan etmezseniz, bu global bir değişken değildir.
manu

1
"Güvenli" veya "Doğru", belirtimi olmayan hiçbir şey ifade etmez. Bunlar koda yönelik bir şartname koyma girişimleridir: Türler, Sınıf Tanımları, DesignByContract, vb. Özel veri sınırlarını dokunulmaz kılabilmek için "Güvenlik" elde edersiniz; yürütmek için sanal makine yönergelerine uymanız gerektiğini varsayarsak. Nesne Yönlendirme, dahili belleği doğrudan belleği okuyabilen birinden gizlemez ve kötü bir nesne protokolü tasarımı sırları tasarımla dağıtır.
Rob
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.