Genç beyinlerin işaretçi kavramlarını öğrenmeye ihtiyacı var mı?

C ustası Dennis Ritchie neden C'ye işaretçiler getirdi? Ve neden VB.NET veya Java veya C # gibi diğer programlama dilleri onları ortadan kaldırdı? Google’da bazı noktalar buldum ve yorumlarınızı da dinlemek istiyorum. Modern dillerde işaretçi kavramlarını neden yok ediyorlar?

İnsanlar, C'nin temel dil olduğunu ve işaretçilerin, C'yi güçlü ve üstün kılan ve C'yi daha modern dillerle rekabet edebilecek bir kavram olduğunu söylüyor. Öyleyse neden daha modern dillerde işaretçileri ortadan kaldırdılar?

Yeni programcılar için işaretçi bilgilerinin hala önemli olduğunu düşünüyor musunuz? İnsanlar bugünlerde VB.NET veya Java kullanıyor, bu da C'den daha gelişmiş özellikleri destekliyor (ve herhangi bir işaretçi konseptini kullanmıyor) ve şimdi gördüğüm gibi birçok kişi (arkadaşlarım) bu özellikleri C'yi yok sayarak gelişmiş özellikleri desteklediklerini söylüyor. Onlara C ile başlamalarını söylüyorum. VB.NET veya Java’da C’de mümkün olmayan gelişmiş şeyleri yaparken işaretçiler kavramlarını öğrenmenin boşa olduğunu söylüyorlar.

Ne düşünüyorsun?

Güncelleme :

Google'da okuduğum yorumlar:

1. Önceki bilgisayarlar çok yavaştı ve optimize edilmedi.

2. İşaretçileri kullanmak, bir adrese doğrudan erişmeyi mümkün kılar ve bu, işlev çağrılarında bir kopyasını yapmak yerine zaman kazandırır.

3. İşaretçiler kullanılarak güvenlik önemli ölçüde daha kötüdür ve bu nedenle Java ve C # bunları içermez.

Bunlar ve biraz daha ne buldum. Hala bazı değerli cevaplara ihtiyacım var. Bu çok takdir edilecektir.

O günlerde, geliştiriciler metale çok daha yakın çalışıyorlardı. C aslında montaj için neredeyse mümkün olan en yakın donanıma sahip olan daha üst seviye bir değiştirmeydi, bu yüzden kodlama problemlerini çözmede etkin olması için işaretçilere ihtiyacınız vardı. Ancak, işaretçiler dikkatsizce kullanılırsa büyük hasara neden olabilecek keskin araçlardır. Ayrıca, doğrudan işaretçilerin kullanılması, o zamanlar sorun olmayan pek çok güvenlik sorununun ortaya çıkmasına neden oluyor (1970'de, internet birkaç üniversitede birkaç düzine makineden oluşuyordu ve bu şekilde çağrılmadı bile). ...), ancak o zamandan beri daha önemli hale geldi. Bu nedenle günümüzde yüksek seviye diller, ham bellek işaretçilerinden kaçınmak için bilinçli olarak tasarlanmıştır.

"VB.Net veya Java’da C: C’de yapılması mümkün değildir" demek, çok az bir şey söylemek için çok sınırlı bir bakış açısı gösterir.

Her şeyden önce, tüm bu diller (hatta meclis) tamamlanmıştır, böylece teoride mümkün olan her dilde mümkün olan her şey mümkündür. Sadece bir parça VB.Net veya Java kodu derlendiğinde ve çalıştırıldığında ne olacağını düşünün: sonunda, makine koduna çevrilir (veya haritalanır), çünkü makinenin anladığı tek şey budur. C ve C ++ gibi derlenmiş dillerde, bir veya daha fazla çalıştırılabilir dosya / kitaplık olarak, orijinal üst seviye kaynak koduna eşdeğer makine kodunun tamamını alabilirsiniz. VM tabanlı dillerde, programınızın tüm eşdeğer makine kod gösterimini elde etmek daha zordur (ve mümkün olmayabilir), ancak çalışma zamanı sisteminin ve JIT'in derin girintileri içinde yine de bir yerdedir.

Şimdi, elbette, bazı çözümlerin belirli bir dilde uygulanabilir olup olmadığı tamamen farklı bir sorudur. Hiçbir mantıklı geliştirici montajda bir web uygulaması yazmaya başlamaz :-) Ancak, bu üst düzey dillerin çoğunun veya tamamının çok miktarda çalışma zamanı ve sınıf kitaplığı kodunun, büyük bir yığınının üzerine kurulu olduğunu akılda tutmak yararlıdır. daha düşük bir dilde, tipik olarak C dilinde uygulanır.

Yani soruya ulaşmak için,

Gençlere yönelik işaretçiler hakkındaki bilgilerin […] önemli olduğunu düşünüyor musunuz?

İşaretçilerin arkasındaki kavram dolaylıdır . Bu çok önemli bir kavram ve IMHO her iyi programcının belli bir seviyede kavramasını sağlamalı. Birisi yalnızca daha yüksek seviyeli dillerle çalışsa bile, aktarma ve referanslar hala önemlidir. Bunun anlaşılmaması, uzun vadede bir kişinin problem çözme yeteneğini ciddi şekilde sınırlayan, çok güçlü bir araç sınıfının tamamını kullanamamak anlamına gelir.

Bu yüzden cevabım evet, gerçekten iyi bir programcı olmak istiyorsanız, işaretçileri de anlamalısınız (özyinelemenin yanı sıra - bu, tomurcuklanan geliştiriciler için diğer tökezleyen bloktur). Başlamanız gerekmeyebilir - C'nin bugünlerde ilk dil olarak uygun olduğunu düşünmüyorum. Ancak bir noktada, bir dolaylı anlatıma aşina olunmalıdır. Onsuz, kullandığımız araçların, kütüphanelerin ve çerçevelerin gerçekte nasıl çalıştığını asla anlayamayız. Ve aletlerinin nasıl çalıştığını anlamayan bir zanaatkar çok kısıtlıdır. Yeterince adil, bir de bunu daha üst seviye programlama dillerinde kavrayabilir. İyi bir turnusol testi, iki kat bağlantılı bir listeyi doğru şekilde uygulamaktır - eğer en sevdiğiniz dilde yapabilirseniz, dolaylı olarak yeterince iyi anladığınızı iddia edebilirsiniz.

Ancak, başka hiçbir şey için değilse, sahip oldukları gülünç basit araçları kullanarak inanılmaz şeyler inşa etmeyi başarmış yaşlı programcılara saygı duymayı öğrenmeliyiz. Hepimiz devlerin omuzlarında duruyoruz ve devleri kendimizmiş gibi davranmak yerine, bunu kabul etmemiz bize iyi geliyor.

Bence farklı olmalısın.

Java ve diğer yüksek seviye dilleri, işaretçileri kaldırmadı. Yaptıkları, düz gösterici aritmetiğini kaldırmaktı.

Aslında, Java korunan ve kısıtlanmış bir işaretçi aritmetiğine izin verir : dizi erişimi. Düz eski C'de, dizi erişimi kural dışı bırakmadan başka bir şey değildir. Yaptığınız şeyi açık bir şekilde iletmek, yapacaksanız farklı bir gösterimdir, sözdizimsel bir şekerdir.
Yine de, array[index]eşdeğerdir *(array+index). Bundan dolayı, index[array]bazı C derleyicilerinin bunu yaparsanız size bir uyarı verebileceğini varsayalım.
Sonuç pointer[0]olarak eşdeğerdir *pointer. Bunun sebebi "bir diziye işaretçi" nin dizinin ilk girişinin adresi olması ve izleyen elemanların adreslerinin indeks eklenerek hesaplanmasıdır.

Java'da, düz işaretçi aritmetik (referanslama ve yeniden düzenleme) artık mevcut değil. Ancak işaretçiler var. Onlara referans derler, fakat ne olduğunu değiştirmez. Ve dizi erişimi hala tam olarak aynı şey: Adrese bakın, dizini ekleyin ve bu bellek konumunu kullanın. Ancak, Java’da, endekste ayırdığınız dizinin sınırları dahilinde olup olmadığını kontrol eder. Değilse, bir istisna atar.

Şimdi Java yaklaşımının avantajı, kodunuzun olmaması, sadece rasgele baytları rasgele bellek konumlarına yazma kabiliyetine sahip olmasıdır. Bu, güvenliği ve güvenliği de artırır, çünkü arabellek taşmalarını ve benzeri şeyleri kontrol etmekte başarısız olursanız, çalışma zamanı sizin için yapar.

Bunun dezavantajı, basitçe daha az güçlü olmasıdır. C de güvenli bellek programlama yapmak mümkündür. Java’daki güvenli olmayan programlamanın hızından ve olanaklarından yararlanmak mümkün değildir.

Aslında, işaretçiler veya işaretçi aritmetiği ile ilgili hiçbir zor şey yoktur. Sadece normalde açık bir şekilde açıklanırlar, tüm işaretçi tek bir dev dizinin indeksidir (bellek alanınız), bir değere yapılan tüm referanslar size onu nerede bulacağınıza dair indeks verir, tüm referansların kaldırılması ne yapar verilen bir dizindeki değer. (Bu biraz basitleştirilmiştir, çünkü değerlerin türlerine bağlı olarak bellekte farklı boyutta oldukları dikkate alınmaz. Ancak bu, gerçek konseptin bir parçası olmaktan çok, bir detay niteliğindedir)

IMHO, işimizdeki herkes bunu anlayabilmeli ya da sadece yanlış alanda bulunmalı.

İşaretçiler kavramı, genel bilgisayar programlama bilgisinde önemlidir. Kavramı anlamak, dil doğrudan desteklemese bile, programcı veya herhangi bir dilin programcıları için iyidir.

İşaretçiler, Veri Yapıları (bağlantılı listeler) ve Veritabanı tasarımında (Yabancı Anahtar) kullanım alanına sahiptir.

VB ve C # gibi diller, verileri bir işaretçi türü olarak düşünülebilecek yöntemlere "referans" yaparak iletebilir.

Verilerin bellekte nereye dağıldığını anlamak (yığın-yığın) algoritmaların etkinliği için hala önemlidir.

Temel bilgileri doğru öğrenmek bence önemlidir.

Evet, evet, evet, evet ve evet !!!

Temel bilgileri bilmiyorsanız, yolunuza çıkan gerçekten zor, garip, zor ve karmaşık sorunları ASLA çözemezsiniz.

Temel bilgileri gerçekten iyi anlarsanız, iş piyasasında ÇOK daha pazarlanabilirsiniz.

Bir keresinde 10 senedir programlama yapan bir adamla çalıştım ve işaretçilerin nasıl çalıştığını bilmiyordum. Ben (çok daha küçük) onu eğiten bir beyaz tahtada saatler geçirdim. Bu gözlerimi açtı. Birçok temel şey hakkında IDEA'sı yoktu.

Olabildiğince çok şey bil.

Evet, anlayış önemlidir.

Birkaç ay önce C # ile programlama yaptım ve bir listenin kopyasını almak istedim. Elbette yaptığım şeydi NewList = OldList;ve sonra değişmeye başladı NewList. Her iki listeyi de basmaya çalıştığımda, ikisi de aynıydı, çünkü bir kopya NewListiçin bir işaretçidi OldList, bu yüzden aslında baştan başa değişiyordum OldList. Bunu anlamak çok uzun sürmedi, ancak sınıf arkadaşlarımdan bazıları o kadar hızlı değildi ve bunun neden olduğunu açıklamak zorunda kaldılar.

Örnek:

List<int> a = new List<int>();
a.Add(2);
a.Add(9);
a.Add(8);
a.Add(1);
List<int> b = new List<int>();
b = a; //Does not make a copy, b is just a synonym!
b.Sort();
for (int i = 0; i < a.Count; i++)
{
    Console.WriteLine("a: " + a[i] + " b: " + b[i]);
}

Ve elbette, sonuç şöyle:

a: 1 b: 1
a: 2 b: 2
a: 8 b: 8
a: 9 b: 9

Onları nasıl kullanacağını bilmek o kadar önemli değil, ama onları anlamak çok önemlidir!

İşaretçi kavramı! = İşaretçi aritmetiği! = İşaretçi işaretçisi

İlk önce her zaman, derin / sığ kopyanın anlaşılması (ve buna ihtiyacınız olduğunda), referansa göre / değere göre geçme, vb. Anlamayı öğrenirseniz önemlidir.

C ustası Dennis Ritchie neden C'ye işaretçiler getirdi?

Çünkü işaretçiler birçok yönden kullanılabilecek çok güçlü bir mekanizmadır.

Ve neden VB.NET veya Java veya C # gibi diğer programlama dilleri onları ortadan kaldırdı?

Çünkü işaretçiler birçok yönden kötüye kullanılabilecek çok tehlikeli bir mekanizmadır.

Programcıların işaretçiler hakkında bilgi edinmesi gerektiğini düşünüyorum, ancak eğitim açısından bakıldığında, bunları erken tanıtmak pek akıllıca değil. Bunun nedeni, birçok farklı amaç için kullanılmalarıdır, bir işaretleyiciyi neden belirli bir durumda kullandığınızı yeni başlayanlar olarak söylemek zordur.

İşaretçilerin ne için kullanıldığı tam bir liste:

• dinamik ayırma ( new T)
• özyinelemeli veri yapıları ( struct T { T* next; /* ... */ };)
• dizilerde yineleyiciler ( for (T* p = &a[0]; p != &a[0] + n; ++p) { ... })
• nesnelere paylaşılan erişim ( T* new_pointer = existing_pointer;)
• Türü Polimorfizmi ( T* pointer_to_base = pointer_to_derived;)
• reference ( mutate(&object);) tarafından eski arama
• isteğe bağlı türleri ( if (p) { /* ... */ })

Tüm bu kavramlar için tek bir mekanizma kullanmanın, deneyimli programcının hem gücünü hem de zerafetini ve programlamaya yeni başlayan biri için büyük karışıklık potansiyelini gösterdiğine dikkat edin.

Neden? Form tasarımcısı ve kod üreticisi ile büyük bir sistem yazabilirsiniz. Yeterli değil mi? (hiciv, alay, ince alay)

Ve şimdi ciddiyetle, işaretçiler birçok alanda programlamanın çok önemli bir parçası değildir, ancak insanların iç işlerin nasıl yürüdüğünü anlamalarına izin verir. İnternalların nasıl çalıştığını anlayabilecek hiç kimseye sahip olamayacaksak, SQL2020, Windows 15 ve Linux 20.04'ün, IDE aracılığıyla oluşturulan kodla JavaScript üzerinden, 30 soyutlama katmanının üzerinde çalışan çöp toplanan sanal makineye yazılacağı bir durum olacaktır. .

Kesinlikle görmek istediğim bu değil.

Yani evet, kesinlikle yapmak zorundalar!

Ne Java, ne de C # işaretçileri yok etti, neredeyse aynı olan referansları var. Elimine edilen şey, tanıtıcı bir derste çıkarılabilecek işaretçi aritmetiktir.
İşaretçiler veya referanslar kavramı olmadan önemsiz bir uygulama yapılamaz, bu yüzden öğretmeye değer (onlarsız dinamik hafıza tahsisi yapılamaz).

C ++ ve Java'da aşağıdakileri göz önünde bulundurun ve C # 'da çok farklı olmadığını tahmin ediyorum:
aClass *x = new aClass();
aClass x = new aClass();
İşaretçiler ve referanslar arasında gerçekten çok fazla fark yok, değil mi?
Gerekmedikçe ve yüksek seviye modellerle programlama yaparken, işaretçi aritmetik özelliklerinden kaçınılmalıdır, bu nedenle orada fazla bir sorun yoktur.

Profesyonel programcı işaretçilere hakim olmalıdır.

Programlamayı bilmek isteyen insanlar varlığını ve sonuçlarını öğrenmeli, ancak bunları mutlaka kullanmamalıdır.

Kişisel problemleri programlama yoluyla çözmek isteyen insanlar (benim gibi, çok fazla Python senaryosu kullananlar), onları çok iyi görmezden gelebilirler.

Peki, bu benim düşüncem ...; o)

Değişken adres işaretçileri, daha genelleştirilmiş dolaylı aktarım kavramının özel bir örneğidir. İndirme, çoğu (tümü?) Modern dilde delegeler ve geri aramalar gibi birçok yapıda kullanılır. Dolaylılık kavramını anlamak, bu araçların ne zaman ve nasıl kullanılacağını bilmenizi sağlar.

Absufreakinglutely EVET ! Program yapan herkesin işaretçileri ve dolaylı ifadeleri anlaması gerekir.

İşaretçiler, tüm dillerde büyük miktarda veri erişiminin nasıl yapıldığını gösterir. İşaretçiler tüm mikroişlemcilerin bir donanım özelliğidir. Java, VB ve C # gibi yüksek seviyeli diller, esas olarak referanslarla dilin kullanıcılarının işaretçilerine doğrudan erişim sağlar. Referanslar, dilin bellek yönetimi şeması aracılığıyla nesnelere atıfta bulunur (örneğin, meta verileri olan bir işaretçi veya bir bellek tablosu için sadece bir sayı olabilir).

İşaretçilerin nasıl çalıştığını anlamak, bilgisayarların gerçekte nasıl çalıştığını anlamak için çok önemlidir . İşaretçiler de referanslardan daha esnek ve güçlüdür.

Örneğin, dizilerin sıfır dizininde başlatılmasının nedeni, dizgelerin işaretçi aritmetiği için kısa yol olmasıdır. İşaretçilerin nasıl çalıştığını öğrenmeden, pek çok başlangıç ​​programcısı dizileri tam olarak elde edemez.

int a, foo[10];
foo[2] = a;

İşaretçi aritmetiğindeki 2. satır:

*(foo + sizeof(int) * 2) = a;

İşaretçileri anlamadan kimse bellek yönetimini, yığını, yığını ve hatta dizileri anlayamaz! Ek olarak, fonksiyonların ve nesnelerin nasıl iletildiğini anlamak için işaretçileri ve referanslardan çıkarmaları anlamak gerekir.

TL: DR : İşaretçileri anlamak, gerçekten çalışan bilgisayarları anlamak için temeldir .

Programcılar üzerinde çalıştıkları doğrudan donanım ile daha az uğraşırken, işaretçilerle başa çıkma ihtiyacının azaldığını düşünüyorum. Örneğin, bir bağlantılı liste veri yapısının, uzmanlaşmış donanımın sahip olduğu 640 bayt bellek modülü sırasına tam olarak uyacak şekilde tahsis edilmesi.

İşaretçilerle manuel olarak ilgilenmek hataya eğilimli olabilir (bellek sızıntılarına ve sömürü koduna neden olabilir) ve doğru olması zaman alıcıdır. Böylece Java ve C # etc artık hafızanızı ve işaretçilerinizi Sanal Makineler (VM'ler) aracılığıyla sizin için yönetiyor. Bu tartışmalı olarak, VM'lerin sürekli olarak iyileştirilmesine rağmen, ham C / C ++ kullanmaktan daha az etkilidir.

C (ve C ++), özellikle Yüksek Performanslı Bilgi İşlem, Oyun ve gömülü donanım alanlarında hala yaygın olarak kullanılan dillerdir. Java'nın referanslarına geçiş (işaretçilere benzer bir kavram) çok kolay olduğu ve ilk NullPointerException'ımı (gerçekten NullReferenceException olarak adlandırılması gerekir) gördüğümde, işaretçilerden öğrendim. .

Hala bir çok veri yapısını desteklediğinden, işaretçiler kavramını öğrenmeyi tavsiye ediyorum. Ardından, çalışmayı sevdiğiniz bir dili seçmeye devam edin, NPE gibi bir şey olursa, gerçekten neler olduğunu bildiğinizi bilin. .

Nesnel gerçek budur:

Bazı diller doğrudan belleğe erişimi (işaretçiler) destekler, bazıları desteklemez. Her durum için iyi sebepler var.

1. Burada birinin söylediği gibi, C günlerinde, otomatik bellek yönetimi bugün olduğu kadar ayrıntılı değildi. Her nasılsa, insanlar buna alışmıştı. O zamanlar iyi programcılar, bilgisayar programlarını kuşağımızdan çok daha derin bir anlayışa sahiptiler (ben 21). Ana bilgisayarda bir derleme zamanı için delikli kartlar ve bekleme günleri kullanıyorlar. Muhtemelen kodlarındaki her bitin neden var olduğunu biliyorlardı.

2. C gibi dillerin bariz avantajı, programınız üzerinde daha iyi kontrol sahibi olmanıza izin vermesidir. Bugünlerde gerçekten ne zaman ihtiyacın var? Yalnızca işletim sistemi ile ilgili programlar ve çalışma zamanı ortamları gibi altyapı uygulamaları oluştururken. Yalnızca iyi, hızlı, sağlam ve güvenilir bir yazılım geliştirmek istiyorsanız, otomatik bellek yönetimi genellikle daha iyi bir seçimdir.

3. Gerçek şu ki, doğrudan hafızaya erişim çoğunlukla yazılım geliştirme tarihi boyunca kötüye kullanılıyor. İnsanlar bellek sızdıran programlar oluşturuyorlardı ve fazla bellek ayırma nedeniyle gerçekte daha yavaştırlardı (C'de işlemin her bir tahsis için sanal bellek alanını genişletmek kolay ve yaygındı).

4. Bu günlerde, sanal makineler / çalışma süreleri, programlayıcıların% 99'undan bellek ayırma ve serbest bırakma konusunda çok daha iyi bir iş çıkarmaktadır. Bunun yanı sıra, programınızın sahip olmasını istediğiniz akışta size ekstra esneklik sağlarlar, çünkü (çoğunlukla) doğru zamanda ve yerde tahsis edilmiş belleği serbest bırakmakla meşgul değilsiniz.

5. Bilgi gelince. Programcıların, programladıkları ortamların nasıl uygulandığını bilmesinin çok şaşırtıcı olduğunu düşünüyorum. En küçük detaylara değil, büyük resme.

İşaretçilerin nasıl çalıştığını (en azından) bilmenin ilginç olduğunu düşünüyorum. Polimorfizmin nasıl uygulandığını bilmek gibi. İşleminizin hafızasını nereden aldığı ve nasıl. Bunlar kişisel olarak her zaman ilgimi çeken şeyler. Dürüst olmak gerekirse, beni daha iyi bir programcı yaptığını söyleyebilirim, ancak iyi bir programcı olmak isteyen herkes için bir eğitim gerekliliği olduğunu söyleyemem. Her iki durumda da, daha fazlasını bilmek işinizi daha iyi hale getirecek .

1. Gördüğüm gibi, yapmanız gereken tek şey Java veya C # ile bir uygulama oluşturmak ya da onun gibi bir şeyse, uygun tasarım ve uygulama tekniklerine odaklanmanız gerekir. Test edilebilir kod, temiz kod, esnek kod. Bu sırayla.

Çünkü tüm küçük ayrıntıları bilmeseniz bile, yapan kişi, yarattığınız şeyi, daha iyi performans gösteren bir şeyle değiştirebilir. Ve bu genellikle zor bir iş değildir; uygun, temiz ve test edilebilir bir tasarımınız olduğunda (ve genellikle işin çoğu budur).

Bir üst seviye dil başvurusu için birini işe almak isteyen bir görüşmeci olsaydım, bunlar en çok ilgilendiğim şeyler olurdu.

Düşük seviye bilgisi bir bonustur. Hata ayıklamak ve zaman zaman biraz daha iyi çözümler üretmek için iyidir. Bu sizi profesyonel olarak ilginç biri yapar. İş yerinizde size saygı duyulmasını sağlar.

Ancak günümüz dünyasında, bu kutsal bir gereklilik değildir.

Yüksek düzeyde OO dillerinde referansları anlamak çoğu pratik amaç için yeterlidir, bu dillerin işaretçiler açısından referansları nasıl uyguladığını anlamanıza gerek yoktur.

Çok fazla fonksiyonel ve modern multi-paradigma yaklaşımı var, söyleyeceğiniz süslü işaretçi aritmetiğini yapabilmekten çok daha fazla değer veriyorum, muhtemelen std lib'inizin String.copy'sinden daha kötü performans gösteren 1000'inci optimize dize kopyalama fonksiyonunu yazın.

Öncelikle çok daha farklı, daha üst düzey konseptler öğrenmenizi ve donanıma yakın konularda uzmanlaşmaya başlamadan önce ufkunuzu genişletmek için farklı tasarımların dillerini öğrenmek isterim.

Önbellekleme (notlama), SQL-optimizasyon veya sadece web sunucusu yapılandırma ayarları az bir çaba ile% 100 veya daha fazla sonuç verirken, web servletini veya% 5 kazanç için benzer kodu mikro olarak optimize etmek için tamamen başarısız girişimler görüyorum. İşaretçilerle uğraşmak çoğu durumda erken optimizasyondur .

Elbette, eğer gerçekten iyi bir programcı olmak istiyorsanız, kapsamlı bir işaretçi kavramına sahip olmamız gerekir. Pointer konseptinin sebebi, zaman kısıtlamaları ile daha verimli ve daha etkili hale gelen değere doğrudan erişim oldu ...

Ayrıca, Bugünlerde çok sınırlı bir Hafızası olan Mobil Uygulamalar düşünüldüğünde, kullanıcı yanıtıyla işleminin çok hızlı olması için onu çok dikkatli kullanmamız gerekiyor ... Bu nedenle, bu amaçla değere doğrudan bir referansa ihtiyacımız var ...

Yalnızca işaretçi konsepti ile çalışan Apple cihazlarını veya Objective C dilini göz önünde bulundurun. Amaç C'de belirtilen tüm değişken Pointer'a sahiptir. Sen geçmesi gerekir Amaç C'nin wiki