Başlangıç ​​C ++ ile Programlama Hileler Sayfası - mankenler

Stephen R. Davis

C ++, hakim olmak için kolay bir programlama dili değildir. Tecrübe yoluyla sayısız sembol kombinasyonları sizin için doğal görünmeye başlayacaktır. Bununla birlikte, bu Hile Sayfası, C ++ başlayıcısından C ++ gurusuna geçişi kolaylaştırmak hakkında bazı sağlam ipuçları verir: Karmaşık C ++ ifadelerinin nasıl okunacağını bilin; işaretçi problemlerinden nasıl kaçınacağınızı öğrenir; ve nasıl ve ne zaman derin kopyalar çıkaracağınızı öğrenin.

Karmaşık C ++ İfadesi Nasıl Okunur

C ++ her biri ifadelerin anlamını arttıran küçük sembollerle doludur. C ++ dilbilgisi kuralları çok esnektir ve bu semboller neredeyse imkansız karmaşık kombinasyonlarda birleştirilebilir. Daha basit C deyimindeki ifadeler, o kadar gizgü olabilir ki, en karanlık programı kimin yazabileceği ve kimlerin anlayabileceği için yıllık bir yarışma olmalıydı.

Karmaşık kod yazmaya çalışmak iyi bir fikir değildir; ancak bazen ilk bakışta biraz şaşkın olan C ++ ifadelerine rastlarsınız. Bunları çözmek için aşağıdaki adımları uygulayın:

1. En çok gömülü parantezlerden başlayın.

   En dış parantezleri aramaya başlayın. Bunlar içinde, gömülü parantez arayın. En derin parantez çifti için yolunuzu bulana kadar işlemi tekrarlayın. Bu alt ifadeyi ilk önce aşağıdaki kuralları kullanarak değerlendirmeye başlayın. Bu ifadeyi anladıktan sonra bir sonraki seviyeye geri dönün ve işlemi tekrarlayın.

2. Parantez içerisinde, her işlemi öncelik sırasına göre değerlendirin.

   Operatörlerin değerlendirilme sırası, tabloda gösterilen operatörün önceliğine göre belirlenir. Yönlendirme, eklemeden önce gelen çarpmadan önce gelir; dolayısıyla aşağıdaki ifade * ptr'nin işaret ettiği değeri 1 artı 2 kat artırır.

int i = 1 + 2 * * ptr;

Öncelik sırasına göre operatörler

Öncelik	Operatör	Anlamı
1	() (tekli)	Bir işlev çağırın
2	* ve -> (	İşaretçiyi referans dışı bırak
2	- (tekli)	İşaretçisinin negatifini döndürür
3	++ (tekli)	Artış
3
4	(ikili)
		Azaltma
4		Modül
5	+ (ikili)	İlave
5	- (ikili)	Çıkarma
6	&& (ikili)	Mantıksal VE
6	! !	Atama türleri
Aynı önceliğin soldan sağa doğru işlemlerini değerlendirir (atama, sıralama, diğer tarafa gider).	Aynı öncelikli operatörlerin çoğu soldan sağa doğru değerlendirir. Böylece aşağıdakiler 1'den 2'ye ekler ve sonucu 3'e ekler:	int i = 1 + 2 + 3;

1. Bazı operatörlerin değerlendirme sırası önemli değil. Örneğin, ekleme soldan sağa doğru, sağdan sola doğru çalışır. Değerlendirme sırası, bölüm gibi bazı işlemler için çok fark yaratıyor. Aşağıdaki 8 x 4 böler ve sonucu 2 ile böler:

   int i = 8/4/2;

   Bu kuralın başlıca istisnası, sağdan sola değerlendirilen atamadır:
   

   a = b = c;

   Bu, c'ye c'ye ve sonucun a'ya atanır.
   

   Alt ifadeleri belirli bir sırayla değerlendir.

   Aşağıdaki ifadeyi göz önünde bulundurun:
   

   int i = f () + g () * h ();

2. Çarpma önceliği daha yüksek, bu nedenle g () ve h () işlevlerinin f () önce çağrıldığını varsayabilirsiniz, ancak durum böyle değildir. İşlev çağrısı, herkesin en yüksek önceliğine sahiptir; bu nedenle, çarpma veya ekleme gerçekleştirilmeden önce üç işlevin hepsi çağrılır. (G () ve h () 'den döndürülen sonuçlar çarpılır ve f ()' den döndürülen sonuçlara eklenir.

   Fonksiyona yan etkiler söz konusuysa, işlevin çağrılma sırası fark yaratır bir dosyayı açma veya bir genel değişkenin değerini değiştirme gibi. Programlarınızı kesinlikle bu tür yan etkilere bağımlı kalacak şekilde yazmamalısınız.

   Gerekli olduğunda yalnızca herhangi bir tür dönüşüm gerçekleştirin.
   

   Kesinlikle gerekli olanlardan daha fazla tür dönüştürme yapmamalısınız. Örneğin, aşağıdaki ifadede en az üç ve muhtemelen dört tür dönüşüm vardır:

   float f = 'a' + 1;

3. Eklemeyi gerçekleştirmek için char 'a' int değerine yükseltilmelidir. Sonra int bir çift dönüştürülür ve daha sonra tek bir hassasiyet şamandırasına dönüştürülür. Tüm aritmetik işlemlerin int veya çift olarak yapıldığını unutmayın. Genel olarak karakter türlerinde aritmetik işlem yapmamak ve tek hassasiyetli float'tan tamamen kaçınmak gerekir.

   C ++'da İşaretçi Sorunlarından Kaçınma 5 Yolları

   C ++'da bir
   

   işaretçisi

, bilgisayarın dahili belleğindeki bir nesnenin adresini içeren bir değişkendir. İşaretçilerle C ++ sorunlarını önlemek için bu adımları kullanın:

Bildirilen işaretçileri başlatma. İşaretçi değişkenlerini asla başlatılmamış bırakmayın - başlatılmamış işaretçiler her zaman rasgele değerler içerdiyse işler çok kötü olmazdı - rastgele değerlerin büyük çoğunluğu yasadışı işaretçi değerleridir ve programın kullanılmaya başlar verilmez hemen çökmesine neden olur. Sorun, başlatılmamış değişkenlerin, daha önce kullanılan diğer işaretçi değişkenlerinin değerini alması eğiliminde olmasıdır. Bu sorunları gidermek çok zordur. Başka bir göstericiyi başlatacağınızı bilmiyorsanız, nullptr ile başlatınız. nullptr'nin yasadışı bir adres olduğu garanti edilmektedir.

1. İşaretçileri kullandıktan sonra sıfırlayın.

   Benzer şekilde, işaretçi artık nullptr değerini atayarak artık geçerli olmadığında bir işaretçi değişkeni daima sıfırlayın. Silme özelliğini kullanarak yığına bir bellek bloğu döndürdüğünüzde bu özellikle geçerlidir; yığın belleğini döndürdükten sonra işaretçiyi her zaman sıfırlayın.

   Bellek yığınından ayrılın ve bellek sızıntılarını önlemek için yığını aynı "düzey" düzeyinde döndürün.

2. Her zaman yığınla aynı seviyede soyutlamaya ayırdığınızdan bir bellek bloğu döndürmeyi deneyin. Bu genellikle, aynı çağrı seviyesinde bellek silmeye çalışmak anlamına gelir.

   Gerektiğinde belleği silmek için bir özel durum yakalayın.

3. Hemen hemen her zaman bir istisna olabileceğini unutmayın. İstisnayı yakalamak ve çalışmaya devam etmek isterseniz (programın çökmesine izin vermek yerine), istisnayı yakaladığınızdan ve onları işaret eden işaretçilerin kapsam dışına çıkmadan bellek bloğunu yığına döndüğünüzden emin olun. kayıp.

   Türlerin tam olarak eşleştiğinden emin olun.

4. Her zaman işaretçilerin türlerinin gerekli tür ile eşleştiğinden emin olun. Belirli bir sebep olmaksızın işaretçiyi yeniden yazmayın. Şunları göz önünde bulundurun:

   void fn (int * p); void myFunc () {char c = 'a'; char * pC = & c; fn (int *) pC);}

5. Yukarıdaki işlev, şikayet etmeden derler; çünkü karakter işaretçisi pC, fn (int *) bildirimiyle eşleştirmek için bir int * öğesine yeniden düzenlenmiştir; Ancak, bu program neredeyse kesinlikle çalışmayacaktır. Fn () işlevi, 32-bitlik bir tamsayıya bir işaretçi bekliyor ve bazı rinky-dink 8 bitlik karakterler istemiyor. Bu tür sorunları sıralamak çok zordur.

   Derin Kopyalar Nasıl ve Nasıl C ++ ile Yapılmalıdır?

Kaynakları oluşturucularına ayıran sınıflar normalde bu kaynakların kopyalarını oluşturmak için bir kopya oluşturucu içermelidir. Yeni bir bellek bloğu tahsis etmek ve orijinalin içeriğini bu yeni bloğa kopyalamak, (varsayılan sığ kopya yerine)

derin kopya

yaratması olarak bilinir. Derin kopyaları C ++'da ne zaman ve ne zaman yapacaklarını belirlemek için aşağıdaki adımları kullanın:

Yapıcı kaynak ayırırsa daima derin kopyalar yapın. Varsayılan olarak, C ++, nesnelerin işlevlere geçirilirken veya bir atamanın sonucu olarak "sığ" üye-kopyaların kopyalarını denetler. Varsayılan sığ kopya operatörlerini, yapıcıda kaynak ayıran herhangi bir sınıfın kopyası karşılığıyla değiştirmelisiniz. Ayrılan en yaygın kaynak, yeni operatör tarafından döndürülen yığın belleğidir. Kaynakları ayıran bir sınıf için daima bir yıkıcı ekleyin.

1. Kaynakları atayan bir yapıcı oluşturursanız, bunları geri yükleyen bir yıkıcı yaratmalısınız. İstisna yok.

   Her zaman yıkıcıyı sanal olarak beyan edin.

2. Genel bir başlangıç ​​hatası, yıkıcıyı sanal olarak tanımlamayı unutmaktır. Program, bazı masum programcılar gelip sınıfınızdan miras kalana kadar düzgün çalışacaktır. Program hala çalışıyor gibi görünüyor, ancak taban sınıfındaki yıkıcı düzgün çağrılmayabileceğinden, bellekteki bir elek gibi programınızdaki bellek sızıntıları sonunda çöker. Bu sorunun bulunması zor.

   Kaynakları ayıran bir sınıf için daima bir kopya yapıcı ekleyin.

3. Kopyalayıcı yapıcı, bellek yığından ayırarak ve kaynak nesnenin içeriğini kopyalayarak geçerli nesnenin uygun bir kopyasını oluşturur.

   Kaynakları ayıran bir sınıf için daima atama işlecini geçersiz kılın.

4. Programcıların operatörleri geçersiz kılmamaları önerilmez, ancak atama operatörü bir istisna oluşturur. Yapılandırıcıda kaynak ayıran herhangi bir sınıfın atama işlecini geçersiz kılmalısınız.

   Atama operatörü üç şey yapmalıdır:

5. Sol ve sağ nesnenin aynı nesne olmadığından emin olun. Başka bir deyişle, uygulama programcısının böyle bir şey yazmadığından emin olun (a = a). Eğer öyleyse, hiçbir şey yapmayın.

   Kaynaklarını geri vermek için soldaki nesnedeki yıkıcı ile aynı kodu çağırın.

   Sağdaki nesnenin sol bir nesne içine derin bir kopyasını yapmak için bir kopya oluşturucusu ile aynı kodu çağırın.

   1. Bunu yapamazsan, kopya yapıcıyı ve atama işlecini silerek programı nesnenin kopyalarını oluşturamaz.

   2. Derleyici C ++ 2011 silme yapıcı özelliğini desteklemediğinden bunu yapamıyorsanız, boş bir kopya yapıcı ve atama işleci oluşturun ve bunları diğer sınıfların kullanmasını engellemek için korumalı olarak bildirin.