Ben C ++ 'yı anlamaya çalışan bir C programcısıyım. Çoğu eğitici, aşağıdaki gibi bir kod parçacığı kullanarak nesne somutlaştırmayı gösterir:
Dog* sparky = new Dog();bu, daha sonra yapacağınız anlamına gelir:
delete sparky;bu mantıklı. Şimdi, dinamik bellek tahsisinin gereksiz olduğu durumda, yukarıdakileri kullanmak yerine herhangi bir sebep var mı?
Dog sparky;Sparky kapsam dışına çıktığında yıkıcı çağrılsın mı?
Teşekkürler!
Yanıtlar:
Aksine, genel bir kural olarak kullanıcı kodunuzda hiçbir zaman yeni / silinmemesi gereken ölçüde, yığın tahsislerini her zaman tercih etmelisiniz.
Dediğiniz gibi, değişken yığın üzerinde bildirildiğinde, yıkıcısı kapsam dışına çıktığında otomatik olarak çağrılır, bu da kaynak ömrünü izlemek ve sızıntıları önlemek için ana aracınızdır.
Dolayısıyla, genel olarak, bellek (yeni arayarak), dosya tanıtıcıları, soketler veya başka herhangi bir şey olsun, bir kaynağı ayırmanız gerektiğinde, onu kurucunun kaynağı aldığı ve yıkıcının serbest bıraktığı bir sınıfa sarın. Ardından, yığın üzerinde bu türden bir nesne oluşturabilirsiniz ve kaynağınızın kapsam dışına çıktığında serbest kalacağı garanti edilir. Bu şekilde, bellek sızıntılarından kaçınmanızı sağlamak için yeni / sil çiftlerinizi her yerde izlemeniz gerekmez.
Bu deyimin en yaygın adı RAII'dir.
Ayrıca, özel bir RAII nesnesinin dışında yeni bir şey ayırmanız gerektiğinde, ortaya çıkan işaretçileri nadir durumlarda sarmak için kullanılan akıllı işaretçi sınıflarına bakın. Bunun yerine işaretçiyi bir akıllı işaretçiye iletirsiniz, bu daha sonra ömrünü örneğin referans sayma yoluyla izler ve son referans kapsam dışına çıktığında yıkıcıyı çağırır. Standart kitaplık, std::unique_ptrbasit kapsam tabanlı yönetime sahiptir ve std::shared_ptrpaylaşılan sahipliği uygulamak için saymaya başvurur.
Birçok eğitici, ... gibi bir parçacığı kullanarak nesne somutlaştırmayı gösterir.
Öyleyse keşfettiğiniz şey, çoğu öğreticinin berbat olduğu. ;) Öğreticilerin çoğu, gerekli olmadığında değişkenler oluşturmak için new / delete çağırmak ve ayırmalarınızın ömrünü takip etmekte zorlanmanıza neden olmak dahil olmak üzere size kötü C ++ uygulamaları öğretir.
Yığın üzerinde bir şeyler olması, tahsis ve otomatik serbest bırakma açısından bir avantaj olsa da, bazı dezavantajları vardır.
Yığın üzerinde büyük nesneler ayırmak istemeyebilirsiniz.
Dinamik gönderim! Bu kodu düşünün:
#include <iostream>
class A {
public:
virtual void f();
virtual ~A() {}
};
class B : public A {
public:
virtual void f();
};
void A::f() {cout << "A";}
void B::f() {cout << "B";}
int main(void) {
A *a = new B();
a->f();
delete a;
return 0;
}Bu "B" yazacaktır. Şimdi Stack kullanırken ne olduğunu görelim:
int main(void) {
A a = B();
a.f();
return 0;
}Bu, Java veya diğer nesne yönelimli dillere aşina olanlar için sezgisel olmayabilecek "A" yazdıracaktır. Bunun nedeni, Bartık bir örneğe bir işaretçinizin olmamasıdır . Bunun yerine, bir örneği Boluşturulur ve atürün değişkenine kopyalanır A.
Özellikle C ++ 'da yeniyseniz, bazı şeyler beklenmedik bir şekilde gerçekleşebilir. C'de işaretçileriniz var ve hepsi bu. Onları nasıl kullanacağınızı biliyorsunuz ve HER ZAMAN aynı şeyi yapıyorlar. C ++ 'da durum böyle değildir. Tıpkı bir yöntem için bağımsız değişken olarak bu örnekte bir kullandığınızda, ne olduğunu hayal - şeyler daha komplike olsun ve eğer çok büyük bir fark ETMEZ atiptedir Aveya A*hatta A&(çağrı bazında referans). Birçok kombinasyon mümkündür ve hepsi farklı davranır.
İşaretçiyi kullanmanın nedeni, malloc ile ayrılmış C'deki işaretçileri kullanma nedeni ile tamamen aynı olacaktır: nesnenizin değişkeninizden daha uzun yaşamasını istiyorsanız!
Önleyebiliyorsanız, yeni operatörü KULLANMAMANIZ bile şiddetle tavsiye edilir. Özellikle istisnalar kullanırsanız. Genel olarak, derleyicinin nesnelerinizi serbest bırakmasına izin vermek çok daha güvenlidir.
Bu anti-kalıbı, operatörün ve adresini tam olarak alamayan insanlarda gördüm. Bir işaretçi ile bir işlevi çağırmaları gerekiyorsa, her zaman öbek üzerinde ayırırlar, böylece bir işaretçi elde ederler.
void FeedTheDog(Dog* hungryDog);
Dog* badDog = new Dog;
FeedTheDog(badDog);
delete badDog;
Dog goodDog;
FeedTheDog(&goodDog);Yığını çok önemli bir gayrimenkul olarak ele alın ve çok mantıklı kullanın. Temel pratik kural, mümkün olduğunda yığını kullanmak ve başka bir yol olmadığında yığın kullanmaktır. Nesneleri yığın üzerinde tahsis ederek aşağıdakiler gibi birçok fayda elde edebilirsiniz:
(1). İstisnalar durumunda yığının çözülmesi konusunda endişelenmenize gerek yok
(2). Yığın yöneticinizin gerektirdiğinden daha fazla alan ayırmanın neden olduğu bellek parçalanması konusunda endişelenmenize gerek yoktur.
Endişelenmemin tek nedeni, Dog'un artık yığın yerine yığına tahsis edilmiş olmasıdır. Yani Dog megabayt boyutundaysa, bir sorununuz olabilir,
Yeni / sil rotasına gitmeniz gerekiyorsa, istisnalara karşı dikkatli olun. Ve bu nedenle, nesne ömrünü yönetmek için auto_ptr veya boost akıllı işaretçi türlerinden birini kullanmalısınız.
Yığın üzerine ayırabildiğiniz zaman (yığın üzerinde) yeni bir neden yoktur (herhangi bir nedenle küçük bir yığına sahip olmadığınız ve yığını kullanmak istemediğiniz sürece).
Yığın üzerinde ayırmak istiyorsanız, standart kitaplıktan bir shared_ptr (veya onun türevlerinden birini) kullanmayı düşünebilirsiniz. Bu, shared_ptr için tüm referanslar ortadan kalktığında sizin için silme işlemini gerçekleştirecektir.
Nesnenizi dinamik olarak oluşturmayı seçmenizin başka hiç kimsenin bahsetmediği ek bir neden daha var. Dinamik, yığın tabanlı nesneler, polimorfizmden .
Visual Studio'da da aynı sorunu yaşadım. Kullanmalısınız:
yourClass-> classMethod ();
ziyade:
yourClass.classMethod ();