Merhaba, tekrar hoş geldiniz.
Bu derste, işaretçilerin ve yapıların kullanımından ve birbirleriyle nasıl ilişkili olduklarından
bahsetmek istiyorum.
Bir yapının içindeki elemanların bir işaretçi olmasını sağlayabiliriz
ve daha sonra yapılarımızın kendilerinin de işaretçi olmasını sağlayabiliriz.
İki çok faydalı kavram.
Yani yapı burada önemlidir c iki yapıya işaretçi sağlar.
Dolayısıyla, yapı türünde bir değişken oluşturduğumuzda, bunu bir işaretçi
olarak oluşturabiliriz.
Yapıların işaretçileri, yapıların kendilerinden daha kolay manipüle edilebilir.
Yani yine, bu bir tür notasyonel bir şey, işleri çok
daha kolaylaştırıyor ve aynı zamanda daha verimli.
C dilinin bazı eski uygulamalarında,
bir yapı bir fonksiyona argüman
olarak aktarılamaz, ancak bir işaretçinin bunu yapabileceğini
biliyoruz. Bu da bir yapıyı bildirirken işaretçi
olmasını istemenizin bir başka nedenidir, çünkü
o zaman c'nin eski sürümlerinde onu bir fonksiyona
argüman olarak aktarabilirsiniz.
Bir yapıyı argüman olarak geçirebilseniz bile, bir işaretçi
geçirmek daha verimlidir.
Bunun daha verimli olduğunu biliyoruz. Geçmişte önemli paslaşmaların nasıl daha
verimli olabileceğinden bahsetmiştik.
Bu durumda, daha da verimlidir çünkü
tüm bir yapıyı geçiriyorsanız, yapı büyükse ve çok
sayıda öğe içeriyorsa, yapıdaki tüm öğeleri
bu parametreye kopyalarsınız.
Eğer bir işaretçi geçiriyorsanız sadece adresi kopyalayın.
Bu nedenle, yapılar büyük olabileceğinden, yapılandırılmış
argümanlar olarak işaretçilerle daha da önemlidir.
Pek çok veri gösterimi, diğer yapılara işaretçiler içeren
yapılar kullanır.
Bunu tüm c programlarınızda işaretçi olan yapılarda
ve bahsettiğimiz nedenlerden dolayı çokça göreceksiniz.
Eski sürümlerde bunları parametre olarak geçirebildiğiniz gerçeğini
görmek için ve aynı zamanda daha verimli çünkü her şeyi
değere göre geçirerek yapıyoruz, bu da bir adresi
kopyalamak için bu büyük yapının tüm öğelerini
kopyalamaktan çok daha verimli.
Yani bir yapıyı işaretçi olarak bildirmek oldukça basittir.
Bir değişkeni vurulacak bir işaretçi olarak tanımladığınızda, verinin türünden sonra yıldız
işaretini kullanırsınız.
Ve yapıların gerçekten yeni bir tür olduğunu söyledik.
Bu durumda, her zaman önemli olan tarih yapımız.
Sadece struct date diyoruz ve sonra asterisk date işaretçisini kullanıyoruz
ve muhtemelen bunu null olarak başlatmak isteyeceksiniz.
Çünkü hatırlayın, struct date pointer date struct date date pointer
dediğinizde, bu herhangi bir bellek ayırmaz, gerçek
işaretçiyi saklamak için bellek oluşturur.
İçindeki veriler için bellek oluşturmuyor.
Böylece bu tarih noktasına
ya da başka bir struct date'in adresine atama yapabilir
ya da bunun için başka bir yerde bir bellek ayırabilir
ya da bu şekilde bazı verilerle başlatabilirsiniz.
Dolayısıyla, değişken tarih işaretçisi diğer işaretçiler gibi atanabilir,
atama deyimi ile bugünün tarihini gösterecek şekilde ayarlayabilirsiniz,
bu nedenle zaten bugünün tarihini bildirmiş olsaydık.
Adresini almak için sadece ve işaretini kullanırız.
Böylece normal bir tarih yapısı oluştururuz ve bu bugünün tarihidir.
Böylece üç unsur için hafıza yaratılmış olur.
Sonra işaretçimizi oluşturuyoruz ve ona diğer
tarihin adresini atıyoruz.
Oldukça basit. Bunu normal veri türleriyle yaptık, yapılarla
yaptığınızda da durum farklı değil.
Daha sonra tarih işaretçisinin işaret ettiği veri yapısının herhangi bir üyesine dolaylı olarak erişebilirsiniz.
Bu yüzden şöyle bir şey yapmamız gerekir.
Gün işaretçisi yapısının öğesine erişmek
isterseniz, önce onu referans dışı bırakmanız gerekir.
Bu nedenle, çok anlaşılır olması için bunu parantez içine almak muhtemelen faydalı olacaktır.
Belirli değerleri ayarlamak için bugünün tarihinin işaret
ettiği değeri, bugünün tarihinin işaret
ettiği adresin değerini almak için tarih işaretçisini
referans dışı bırakmanız gerekir.
Bu nedenle, referansı kaldırır
ve ardından nokta gün eşittir 21 yaparsınız ve bu da gün işaretçinize
21 atar.
Şimdi yukarıdaki sadece bugünün tarihi neyi gösteriyorsa, bu değere
erişmek ve günü 21 olarak ayarlamak istediğimizi söylüyor.
Bu durumda, nokta yıldız işaretinden daha yüksek bir önceliğe
sahip olduğu için parantezler gereklidir.
Eğer parantezleri oraya koymazsanız, işaretçiyi veriye yönlendirmek için işaretçiye
gerçekten ulaşmadan önce noktayı yapmaya çalışacağından
işler karışır.
Yani verilere esasen bir null işaretçi ile erişmeye çalışacaktır.
Ve böylece referansı kaldırarak değeri elde edersiniz.
Şimdi yapıları bir işaretçi olarak kullandığımızda.
Eğer date işaretçisinin işaret ettiği tarih yapısında saklanan ayların değerini test etmek istersek,
şöyle bir şey yapabiliriz.
İşaretçinin referansını kaldırırız, parantez içine alırız, böylece noktadan öncelikli
olur ve sonra nokta ay eşittir 12 deriz.
Bu tamamen geçerli bir sözdizimidir.
Ama biraz hantal.
Yani c'nin kendi sözdizimi vardır, bu nedenle yapılar için her şeyi referanstan
çıkarıp bir parantezin içine koymanız gerekmez.
Yapının işaret ettiği şeye erişmek istediğinizde, bu şekilde
referansı kaldırmanız gerekmez.
İşaretçi yapıları için c'de özel bir operatör vardır ve
bu da tire büyüktür.
Bir tire ve ardından büyüktür işareti gelir.
Bu da işaretçiyi referans dışı bırakmanıza gerek kalmamasını sağlar.
Yani parantez içinde yıldız x ve ardından nokta y yapmak yerine,
sadece x çizgi y'den büyük diyebilirsiniz.
x bir işaretçi olduğu için, ona referans vermek zorunda değilsiniz ve işaret
ettiğiniz yapı içindeki öğeye erişmek istiyorsunuz.
Yani bu sözdizimini her yerde göreceksiniz. Parantezleri ve d referansını
görmeyeceksiniz. Bu tamamen geçerli, ancak daha fazla karakter yazıyorsunuz.
Sadece x çizgisinin y'den büyük olduğunu söylemek çok daha etkilidir.
Dolayısıyla, önceki if deyiminde parantezlerin içindeki referansı kaldırmak yerine tek
yapmanız gereken, if date pointer dash greater than month demek.
Ve bu biraz sezgiseldir çünkü tire işareti bir şeye işaret ettiğini söyler.
Ve böylece tarih çizgisi aydan büyük olur.
Tarih işaretçisi bir işaretçidir ve bu yüzden büyüktür tire işaretini kullanırsınız.
Şimdi eğer bu iç içe geçmiş bir yapı olsaydı,
yapıya tire büyük yapardınız ve sonra iç içe geçmiş yapının öğelerine
erişmek için bundan sonra bir nokta yapmanız gerekirdi.
Ancak gün işaretçisi bir işaretçi olduğu için tire eşittir veya tire daha büyüktür
kullanmanız gerekir.
İşte bir örnek, struct date'imizi oluşturuyoruz, üç elemanımız
var, sonra pointer date pointer'ımızı oluşturuyoruz ve sadece normal bir today değişkeni
oluşturuyoruz. İşaretçimize bugünün adresini
atarız ve daha sonra yapının gerçek elemanlarını atamak için,
sadece bu tire büyüktür'ü kullanırız ve sonra yazdırabiliriz.
Şimdi bunun nasıl çalıştığını görmek için kod blokları halinde bakalım.
Bu yüzden bu örneği buraya koyacağım.
Ve genellikle yapıları tanımladığınızda, bunları bir işlevin
dışında tanımlarsınız çünkü daha sonra bunları herhangi bir işlevde kullanabilirsiniz.
Küresel gibi bir şey. Ancak yapıyı tanımladığınızda
aslında herhangi bir bellek oluşturmadığınızı unutmayın.
Yani değişkenleri hala yerel değişkenler veya işaretçiler olarak oluşturursunuz,
ancak asıl tanım fonksiyonun dışındadır.
Yani kullanmak isterseniz herhangi bir fonksiyonda kullanabilirsiniz.
Burada en üstte, date veya name to date türünde yeni bir yapı
oluşturduk ve üç tamsayı içeriyor, noktalı virgülle bitiriyoruz.
Daha sonra main içinde birkaç değişken oluşturuyoruz.
Biri sadece normal bir değişken olan struct date today
ve diğeri de bir işaretçi. Bunun bir işaretçi olduğunu biliyoruz çünkü önünde yıldız işareti var.
Bir işaretçi oluşturduğunuzda, sadece o işaretçinin o değeri için o adresi saklamak
üzere bellek tahsis ettiğini biliyoruz.
Bu nedenle, bugün ampersand ile yaptığımız gibi aslında bir adres atamamız gerekir
çünkü bu aslında bir bellek raporu oluşturur.
Şimdi tarih işaretçisi, bugünün adresi ile bugün
her neyse onu gösterecektir.
Daha sonra bu tire işaretini kullanarak veri atamaya başlayabiliriz. greater than çok kullanışlıdır
ve herhangi biri gibi sadece atama operatörünü kullanarak bir veri atayabiliriz.
Ve sonra bunu yazdırdığımızda, yazdırmak
için referansı kaldırmamız gerekmediğini fark edeceksiniz.
Bunu yazdırmak için,
burada biçim belirleyicileri için veri türlerini söyleyebiliriz yüzde daha yüksek yüzde
d tamsayılar için aynı ve sonra sadece tire notu kullanırız çünkü bu aslında referans
kaldırma işlemini yapar, unutmayın.
Şimdi bunu değiştirebiliriz ve bu geçerli olur.
Parantez içine almamız ve ardından nokta ayını söylememiz gerekiyor.
Her iki şekilde de iyidir, ancak daha iyi sözdizimi olduğu için tire işaretine daha sonra daha büyük olana alışın.
Ve şimdi bunu oluşturduğumuzda,
tarih işaretçileri değerlerini yazdırdığını ve hepsinin
9 25 ve 2015 olarak ayarlandığını göreceksiniz.
Yani bugünün tarihi 9:25:15. Bu şekilde yazdırmak için biçimlendirilmişti.
Oldukça basit şeyler.
Tire işaretinin büyük olduğunu unutmayın; bu, yapılara yönelik
işaretçiler için yeni bir sözdizimidir.
Ama buradaki diğer her şey normal.
İşaretçilerin adresleri saklaması gerektiğini biliyoruz, bu nedenle
ya dinamik bellek ayırmamız ya da mevcut bir yapıya atamamız gerektiğini biliyoruz.
Şimdi geri dönelim ve yapılar ve işaretçiler hakkında daha fazla konuşalım.
Şimdi de işaretçi içeren yapılar hakkında konuşalım.
Bir yapı için nasıl işaretçi oluşturacağımızı biliyoruz.
Mevcut bir işaretçinin mevcut bir adresini atamak istemiyorsak,
bu işaretçi için bellek ayırabiliriz.
Ancak, kendisi bir işaretçi olan bir yapının içinde
de öğelere sahip olabilirsiniz. Yani bir işaretçi de bir yapının üyesi olabilir.
Bu karakter dizisini kullanmak zorunda değiliz.
Yani struct diyebiliriz, işaretçilerle
adlandırabiliriz ve sonra burada bu örnekte iki tamsayı, iki tamsayı işaretçisi p1 ve p2
kullanabiliriz, bunu yapmak için tamamen geçerli sözdizimi.
Böylece, iki tamsayı işaretçisi içerecek şekilde in pointers adlı bir yapı tanımlanır.
Birincisine p1 ve ikincisine p2 denir.
İşaretçilerde struct türünde bir değişkeni normal, struct, int işaretçiler, işaretçiler
gibi tanımlayabilirsiniz.
Değişken işaretçiler artık diğer yapılar gibi kullanılabilir.
İşaretçiler bir işaretçi değildir.
Bu int pointer. Struck içinde işaretçi olan iki öğe içerir,
ancak işaretçilerin kendisi gerçek bir işaretçi değildir.
Bu yüzden buna dikkat edin. Üyeleri olarak iki işaretçi içeren bir yapı değişkenidir,
bu farklıdır.
Dolayısıyla, pointers değişkeninin içindeki
elemanlara erişmek istiyorsak, pointers bir
pointer değil, bir struct olduğu için tire büyüktür ifadesini kullanmayız.
Noktayı p1'e erişmek ve
p2'ye erişmek için kullanırız.
Yani bu örnekte, yapımızı oluşturuyoruz, bir
değişken yaratıyoruz. İşaretçi adı verilen bir işaretçi değil.
Ve sonra 100'e eşit i1 ve başlatılmamış
i2 olmak üzere iki tamsayı oluşturuyoruz.
Şimdi p1 ve p2 birer işaretçidir.
Bu nedenle, adreslerin bellekte tahsis edildiği geçerli bellek adreslerini
içermeleri gerekir.
Ve i1 ve i2'nin yaptığı da budur.
Tamsayı değişkenlerini bildirdiğinizde, bu tamsayılar için bellek ayrılır.
Ve böylece i1 ve i2 adreslerini p1 ve p2'ye atayarak, bu tamamen iyidir çünkü i1 ve i2
için ayrılmış bellek vardır çünkü bunlar tamsayıdır.
Eğer tamsayı işaretçileri tamsayı işaretçisi değil de karakter işaretçisi olsaydı,
o zaman dinamik bellek ayırmanız gerekirdi.
Şimdi sadece tamsayıları kullanıyoruz, bu yüzden iki tamsayının adreslerini p1 ve p2'ye atıyoruz.
Artık yıldız işaretçileri diyebiliriz. p2 eşittir 97, negatif
97.
İşaretçiler olduğu için neden orada referansı
kaldırmak zorundayız? p2 referans aldığımız şeydir.
İşaretçiler. pt p2 bir işaretçidir.
Bir yapının bir unsuruna erişmiyoruz.
Tüm işaretçileri dereferanslıyoruz. p2.
Ve negatif 97'ye işaret eden şeyin değerini atayacağız.
Aradaki farka dikkat edin.
Bir yapı işaretçisi oluşturmuyoruz.
Normal bir değişken işaretçisi oluşturuyoruz,
ancak işaretçi olan iki öğe içeriyor.
Dolayısıyla, yapının içindeki bu iki öğeye atama yapmak istiyorsak, dolaylama operatörünü
kullanarak bunları referans dışı bırakmamız gerekir ve burada
yaptığımız da budur.
Ve sonra iki print deyimimizde.
Yine, p1'in işaret ettiği değerleri yazdırmak istiyoruz, bu yüzden
p2 ile aynı şekilde referansı kaldırıyoruz
ve sonra da işaretçilerin işaret ettiği
değerleri tekrar yazdırmak istiyoruz.
Yani ilkinde i1'in yüzde I virgül işaretçilerine
eşit olduğunu söylüyoruz. p1 yüzde I'e eşittir.
Yani çift tırnak içindeki ilk metin sadece gerçek metni yazdırıyor, virgülden
sonraki hiçbir şeye referans vermiyor, referans vermeyi burada yapıyoruz.
Önce 100 olan i1'i yazdırıyoruz ve ardından 100 olacak
olan p1 işaretçilerini yazdırıyoruz.
I2 aslında p2'ye atandıktan
sonra negatif 97 olacaktır.
Peki karakter dizileri veya karakter işaretçileri ne olacak? Bir önceki derste, bir işaretçinin içinde
bir eleman olarak bir karakter dizisini nasıl oluşturabileceğinizden
bahsetmiştik. Peki ya karakter işaretçileri,
first ve last'in karakter dizileri
olması gibi bir şey mi yapmalıyız
yoksa first ve last gibi karakter işaretçilerinin eleman olduğu
bir şey mi yapmalıyız. En iyi seçenek nedir?
Göreceğiz bakalım. Bu gerçekten yine notasyonel bir şeydir, ancak işaretçileri kullanmanın avantajları vardır.
Bu nedenle, öğelerimizin içindeki karakterlere işaretçiler oluşturduğumuzda,
genellikle biraz daha iyi olur.
Ancak, dizi elemanı char dizisini bir eleman olarak veya bir işaretçiyi
bir eleman olarak oluşturduğunuzda burada neler olup bittiğini anlamanız gerekir, her ikisi
de geçerlidir. Ama arada büyük bir fark var.
Yani struct names veep veya vp
dersek ve Talia ve Summers dersek ve sonra struct
pointer name dersek. Unutmayın, struct names karakter dizilerini içerir.
Struct işaretçi adları işaretçileri içerir.
Ve burada işaretçileri Brad ve Fallingjaw'a eşit olarak başlatıyoruz.
Ve sonra bunları yazdıracağız, a ve vp karakteri
olan ilk öğeyi ve ardından first'e bir işaretçi
olan treas'in ilk öğesini yazdıracağız.
Yani yapı veep değişkenini adlandırır.
Burada olan şey, dizelerin yapının içinde depolanmasıdır.
Yapı, iki ismi tutmak için toplam 40 bayt ayırmıştır, bunlar karakter
dizileridir.
Bir işaretçinin içinde karakter dizileri oluşturduğumuzda olan şey budur.
Bu iki ismi tutmak için 40 bayt ayırıyoruz,
20 ve 20.
İşaretçi adları değişkeni treas için ilk ve son olmak üzere iki işaretçimiz olup olmadığı, bunlar
derleyicinin dize sabitlerini sakladığı her yerde saklanan dizelerdir.
Yapı iki adresi tutar çünkü
bunlar işaretçidir. İşaretçiler, adres olan değerler içerir.
Yani yapacağı tek şey, bu yapının içine iki işaretçi tahsis etmektir.
Bu çoğu sistem için 16 bayttır, işaretçiler genellikle 8 bayt veya 4 bayttır.
struct p name yapısı dizeleri saklamak için yer ayırmaz, çünkü yalnızca
işaretçilerin kendileri için yer ayırır.
İşaretçilerin adres olan değerleri vardır.
İşaret ettiği adres için ayrılmış bir bellek yok.
Yani bu iki işaretçiyi oluşturduğunuzda, bu iki işaretçi için ayrılmış bir bellek yoktur.
Hiç yer ayırmaz.
Bu nedenle, yalnızca başka bir yerde kendileri için yer ayrılmış dizelerle kullanılabilir.
Bir yapı içinde işaretçileriniz olduğunda malloc veya
calloc kullanmanız gerekir.
Aksi takdirde, dize sabitlerinin saklandığı her yerde saklanabilirler.
İşte büyük fark bu. Bu nedenle, işaretçiler ve p name yapısı yalnızca
programın başka bir yerinde oluşturulan ve tahsis edilen dizeleri yönetmek için kullanılmalıdır.
Dinamik olarak tahsis etmediğiniz
veya başka bir yerde, belki mevcut bir yapı veya başka bir şey tarafından
tahsis edilmediği sürece buna veri
atamak istemezsiniz. Ancak tipik olarak, bu işaretçileri malloc etmek isteyeceksiniz.
Yine, çok farklı.
Name struct içindeki bu iki karakter dizisi için 40 bayt ayırıyorsunuz.
p name struct için iki işaretçiniz vardır.
Bu türde bir değişken oluşturduğunuzda bunun için ayrılmış bir bellek yoktur.
Sadece her biri sekiz bayt olan iki karakter işaretçisi için bellek oluşturuyor.
İlk ve sonun işaret ettiği şey için gerçekten bellek ayırmak için bir malloc yapmanız gerekir.
Bu nedenle, dizeleri işlemek için bir işaretçi ve yapı kullanmanın mantıklı
olduğu bir durum, bu belleği
dinamik olarak tahsis ediyor olmanızdır.
Bu genellikle onu kullandığınız zamandır
çünkü izin verilen diğer veri türleri otomatik olarak sizin için bellek ayıracaktır.
Bu yüzden adresi saklamak için bir işaretçi kullanmak istersiniz.
Bunun avantajı, malloc'tan yalnızca bir dize için gereken miktarda alan ayırmasını
isteyebilmenizdir. Dinamik bellek tahsisinin avantajlarından bahsetmiştik.
Derleme zamanında statik olarak bir şeyler oluşturduğunuzda,
yalnızca belirli sayıda bayt oluşturursunuz.
Daha fazla bayta ihtiyacınız olursa ne olacak, mahvoldunuz, programınız çalışmayacak.
Geri dönüp yeniden derlemeniz gerekir. Dinamik olarak ayrılmış dizelerle, yeniden
ayarlayabilir, ihtiyaç duyduğunuz kadar bellek oluşturabilirsiniz, bu da programda
çok daha verimli olmasını sağlar.
Yani bir struct içinde oluşturulan tüm işaretçiler için malloc kullanacaksınız.
Yani bu durumda, name count adında bir yapınız var.
İki işaretçiniz var, fname ve last name karakter işaretçileri.
Ve sonra bir int, harfler var.
Buradaki iki dizge yapıda saklanmaz.
Sadece adresleri içeren işaretçiler için bellek oluşturuyoruz.
İşaretçilerin işaret ettiği şey için fname ve lname için bellek oluşturmak istiyoruz.
Bu yüzden bunu malloc kullanan dinamik bellek konumu tarafından yönetilen bir yığın içinde saklamak istiyoruz.
İki dizenin adresi depolanan şeydir, işaret ettikleri şey değil.
Yani adresler, dize işleme fonksiyonlarının tipik olarak çalıştığı şeylerdir, bu da iyidir
ve bu yüzden orada işaretçiler kullanmak istersiniz çünkü o zaman bunu yapmak
zorunda kalmazsınız, o zaman onları çok daha kolay bir şekilde iletebilirsiniz.
İşte bir örnek. get info adında bir fonksiyonumuz var.
Bir işaretçi gerekiyor.
Ve bu işaretçiyi çok kolay bir şekilde dolaştırabiliriz.
Şimdi de başka bir dizi oluşturacağız
ya da ona aktardığımız işaretçi
dizimiz için bellek ayıracağız.
Böylece temp adında bir karakter oluşturduğumuzu ve daha sonra bu
temp içinde bazı verileri sakladığımızı göreceksiniz.
Kullanıcıdan bir şey almasını istiyoruz. Sgets'e aşina değiliz, ancak gets'in scanf'i biraz kaydetmesiyle aynı.
Sonra bu işaretçinin içinde fname için bellek ayırırız ve bunu herhangi bir karakter için
bellek ayırdığımız gibi yaparız. Malloc'u çağırıyoruz,
bayt sayısını giriyoruz.
Bu durumda, boş sonlandırıcı için str uzunluğu 10 artı 1'dir.
Ve sonra malloc'un bir void yıldızına dönüştüğünü hatırlayın, bu yüzden onu bir karakter yıldızına atıyoruz.
Ama burası çok önemli. Bu malloc çağrısı, işaretçi içeren tüm yapılar için gereklidir.
Şimdi bu işaretçiyi içeri aktardık ve işaretçi için hiçbir zaman bir bellek
ayrılmadı.
Yani burada bellek ayırıyoruz. Daha sonra kopyamızı çok kolay bir şekilde yapabiliriz.
Temp'i parametre olarak aktarılan pst yapımızın fname'ine kopyalayabiliriz.
Ve sonra soyadlarını girmelerini sağlayabiliriz, soyadı için daha fazla bellek malloc
edebiliriz ve sonra soyadı struct değişkeninde saklayabiliriz.
Yapılarınızın içinde karakterlere işaretçiler olduğunda yapmanız
gereken şey budur, malloc yapmanız gerekir.
Çünkü yine, bu işaretçiler yalnızca adresi depolar.
Bir adresi saklamak için yeterli bellek ayırırlar, bir dizeyi
saklamak için yeterli bellek ayırmazlar.
Bu adres neye işaret ediyorsa, onun için bellek ayırmanız gerekir ve bunu
malloc ile normal şekilde yaparsınız, tek
fark burada karakter işaretçisi olan bu yapının içindeki gerçek öğeye
erişmek için tire büyüktür işaretini kullanırsınız, böylece ona atayabilirsiniz
ve bu da de-referanslama yapar.
Bu yüzden bu şeylerle oynamak isteyeceksiniz. Bu, yapıların içindeki karakter
işaretçileri için çok yaygındır.
Bunu yapmanız gereken bir yarışmamız olacak. Ancak bu kodla oynayın, kod bloklarının
içine girin, yapıların içindeki dizeler veya karakter işaretçileri
için bellek ayırmaya başlayın ve daha sonra oraya
veri koymak için str copy'yi nasıl kullanabileceğinizi görün, ancak atamadan
önce belleği ayırmanız gerekir.
Önceki örnekteki gibi sabitler kullanıyorsanız, belleğin nerede tahsis edildiğini kim bilebilir.
Dolayısıyla, bu derste yine pek çok önemli kavram sunulmuştur.
Bu yeni sözdiziminde işaretçi olan bir yapı fikri,
dolaylama operatörünü
kullanmak yerine tire sonra daha büyük kullanabileceğiniz,
çok güzel.
Ve sonra aslında elemanların işaretçi olması ve karakter işaretçileri
için nasıl bellek ayırmanız gerektiği. Teşekkür ederim.