Neden bir std :: vector <AbstractClass> bildiremiyoruz?

C # 'da geliştirmek için epey bir zaman harcadıktan sonra, onu bir arayüz olarak kullanmak amacıyla soyut bir sınıf bildirirseniz, çocuk sınıflarının örneklerini saklamak için bu soyut sınıfın bir vektörünü başlatamayacağınızı fark ettim.

#pragma once
#include <iostream>
#include <vector>

using namespace std;

class IFunnyInterface
{
public:
    virtual void IamFunny()  = 0;
};

class FunnyImpl: IFunnyInterface
{
public:
    virtual void IamFunny()
    {
        cout << "<INSERT JOKE HERE>";
    }
};

class FunnyContainer
{
private:
    std::vector <IFunnyInterface> funnyItems;
};

Soyut sınıfın vektörünü bildiren satır MS VS2005'te bu hataya neden olur:

error C2259: 'IFunnyInterface' : cannot instantiate abstract class

IFunnyInterface'i aşağıdakilerle değiştiren bariz bir çözüm görüyorum:

class IFunnyInterface
{
public:
    virtual void IamFunny()
    {
        throw new std::exception("not implemented");
    }
};

Bu kabul edilebilir bir geçici çözüm C ++ akıllıca mı? Değilse, bu sorunu aşmama yardımcı olabilecek boost gibi herhangi bir üçüncü taraf kitaplığı var mı?

Bunu okuduğunuz için teşekkürler!

Anthony

Soyut sınıfları başlatamazsınız, bu nedenle soyut sınıfların bir vektörü çalışamaz.

Bununla birlikte, sınıfları soyutlamak için bir işaretçi vektörü kullanabilirsiniz:

std::vector<IFunnyInterface*> ifVec;

Bu aynı zamanda polimorfik davranışı gerçekten kullanmanıza da olanak tanır - sınıf soyut olmasa bile, değere göre depolama, nesne dilimleme sorununa yol açar .

Soyut sınıf türünün bir vektörünü oluşturamazsınız çünkü soyut bir sınıfın örneklerini ve std :: vektör saklama değerleri (örn. Örnekler) gibi C ++ Standart Kitaplık kapsayıcılarını oluşturamazsınız. Bunu yapmak istiyorsanız, soyut sınıf türüne yönelik bir işaretçi vektörü oluşturmanız gerekecektir.

Çalışma çevreniz çalışmaz çünkü sanal işlevler (bu nedenle ilk etapta soyut sınıfı istiyorsunuz) yalnızca işaretçiler veya referanslar aracılığıyla çağrıldığında çalışır. Referans vektörleri de oluşturamazsınız, bu nedenle bu, bir işaretçi vektörü kullanmanız gerektiğinin ikinci nedenidir.

C ++ ve C # 'nin çok az ortak yönünün olduğunu anlamalısınız. C ++ öğrenmek istiyorsanız, sıfırdan başlayarak düşünmelisiniz ve Koenig ve Moo tarafından hazırlanan Accelerated C ++ gibi iyi bir özel C ++ öğreticisini okuyun .

Bu durumda bu kodu bile kullanamayız:

std::vector <IFunnyInterface*> funnyItems;

veya

std::vector <std::tr1::shared_ptr<IFunnyInterface> > funnyItems;

Çünkü FunnyImpl ve IFunnyInterface arasında IS A ilişkisi yoktur ve FUnnyImpl ile IFunnyInterface arasında özel kalıtım nedeniyle örtük bir dönüşüm yoktur.

Kodunuzu aşağıdaki şekilde güncellemelisiniz:

class IFunnyInterface
{
public:
    virtual void IamFunny()  = 0;
};

class FunnyImpl: public IFunnyInterface
{
public:
    virtual void IamFunny()
    {
        cout << "<INSERT JOKE HERE>";
    }
};

Geleneksel alternatif, daha vectorönce belirtildiği gibi, bir işaretçi kullanmaktır .

Takdir edenler için, Boostçok ilginç bir kitaplıkla birlikte gelir: Pointer Containersgörev için mükemmel şekilde uygundur ve sizi işaretçilerin ima ettiği çeşitli sorunlardan kurtarır:

• ömür boyu yönetim
• yineleyicilerde çift başvurunun kaldırılması

Bunun vectorhem performans hem de arayüz açısından akıllı işaretçilerden önemli ölçüde daha iyi olduğunu unutmayın .

Şimdi, hiyerarşinizi değiştirmek için 3. bir alternatif var. Kullanıcının daha iyi yalıtımı için, aşağıdaki modelin birkaç kez kullanıldığını gördüm:

class IClass;

class MyClass
{
public:
  typedef enum { Var1, Var2 } Type;

  explicit MyClass(Type type);

  int foo();
  int bar();

private:
  IClass* m_impl;
};

struct IClass
{
  virtual ~IClass();

  virtual int foo();
  virtual int bar();
};

class MyClass1: public IClass { .. };
class MyClass2: public IClass { .. };

Bu oldukça basittir ve bir PimpldeyiminStrategy kalıpla .

Elbette, yalnızca "gerçek" nesneleri doğrudan manipüle etmek istemediğinizde çalışır ve derin kopyayı içerir. Yani dilediğin gibi olmayabilir.

Çünkü bir vektörü yeniden boyutlandırmak için varsayılan kurucuyu ve sınıfın boyutunu kullanmanız gerekir, bu da onun somut olmasını gerektirir.

Diğer önerildiği gibi bir işaretçi kullanabilirsiniz.

std :: vector, türünüzü içerecek bellek ayırmaya çalışacaktır. Sınıfınız tamamen sanalsa, vektör ayırmak zorunda kalacağı sınıfın boyutunu bilemez.

Sanırım geçici çözümünüzle, bir derleme yapabileceksiniz, vector<IFunnyInterface>ancak içinde FunnyImpl'i kullanamayacaksınız. Örneğin, IFunnyInterface (soyut sınıf) boyutu 20 ise (gerçekten bilmiyorum) ve FunnyImpl boyutu 30 ise, çünkü daha fazla üye ve kod içeriyorsa, 20'lik vektörünüze 30'u sığdırmaya çalışacaksınız.

Çözüm, "yeni" ile yığın üzerinde bellek ayırmak ve işaretçileri depolamak olacaktır. vector<IFunnyInterface*>

Bence bu gerçekten üzücü bir sınırlamanın temel nedeni, kurucuların sanal yapamamasıdır. Bu nedenle derleyici, derleme zamanındaki zamanını bilmeden nesneyi kopyalayan bir kod üretemez.