相关疑难解决方法(0)

假设我们有:

class A {
protected:
    int* iArr;
    float *fArr;
public:
    A(int* iArr,float *fArr);
    ~A();
}

class B : public A {
private:
    double *dArr;
public:
    B(int* iArr,float *fArr,double *dArr);
    ~B();
}

我的意思是它只会调用B的析构函数,但是当我在Visual C++上运行它时,我发现在破坏B的实例时它会调用A然后调用B析构函数.

那么在派生类中编写析构函数的正确方法是什么？我总是需要假设父类会处理删除所有内容,但只有派生类有什么？

编辑:

1. 如果是这样,那么如果孩子只用重写函数扩展父类,那是否意味着我将孩子的析构函数留空了？

2. 如果我想改变它怎么办？我的意思是,如果我只想要调用子析构函数？有没有办法做到这一点？

我有一个主要的抽象类,我必须创建基于这个类的子类(这不能被修改):

class Spaceship
{
  protected:
    string m_name;      // the name of the ship
    int m_hull;         // the hull strenght
  public:

    // Purpose: Default Constructor
    // Postconditions: name and hull strength set to parameters
    // -- INLINE
    Spaceship(string n, int h)
    {
      m_name = n;
      m_hull = h;
    }

    // Purpose: Tells if a ship is alive.
    // Postconditions: 'true' if a ship's hull strength is above zero,
    //                 'false' otherwize.
    // -- INLINE
    bool isAlive()
    {
      return (m_hull > 0); …

我的接口层次结构如下：

class A
{
public:
 void foo() = 0;
};

class B: public A
{
public:
void testB() = 0;
};

class C: public A
{
public:
void testC() = 0;
};

现在，我想通过相同的层次结构（即基类）实现这些接口AImpl，BImpl但CImpl我不确定如何从相应的接口派生它们。

请帮忙。提前致谢。

在我的C ++项目中，我有一个Engine类和一个Object类。

我的问题在于如何Object创建实例。当前，这是通过使用类中的CreateObject(parameters)函数来完成的Engine。这增加的新实例Object到std::vector的Object实例。

我想维护此类Object在我的Engine类中的实例列表，但不需要此CreateObject(parameters)功能。我这样做的原因是，我可以创建可以继承Object但仍添加到此列表的新类。使用此列表的原因是为了使（Engine可以）我可以遍历Object已创建的每个实例。

最终这将意味着我Object用类似的实例创建实例Object newObject = Object(parameters);，但仍使Engine该类维护所有Object实例的列表，而无需Object引用的实例Engine或将其自身添加到此列表的列表（如Objectshould 的实例）不知道它所在的列表）。 能做到吗？

我有3节课

class A
{
    A();
    virtual ~A();
}
class B : public A
{
    B();
    ~B();
}
class C
{
    void *obj;
    C() : obj(nullptr) {}
    ~C() { if (obj) delete obj; }
}

当我使用class C作为类的任何子类的容器A并尝试删除C实例时.A,B析构函数是不是很正常？什么是solutuon？

C* instance = new C();
instance.obj = new B();
//Magic
delete instance; // A and B destructor is not called

我有一个基本的界面(在Visual Studio 2013中使用Microsofts C++语法),它公开了这样的简单函数:

__interface IDisposable {
    void Dispose();
};
__interface IBase : public IDisposable {
    void Foo();
    void Bar();
};

有一种特定类型的类必须继承这些方法,因此这些类具有以下结构:

class Derived : public IBase {
public:
    Derived();
    ~Derived();
    void Dispose();
    void Foo();
    void Bar();
}

这些类也有一些变量,我想使用智能指针,但这些指针确实产生泄漏,因为~Derived()在下面的场景中没有调用析构函数:

• 我有一个Stack<IBase*>用来处理一堆这些对象(例如Derived,Derived2等).
• 一旦pCurrent应该从堆栈中删除最顶层的元素()与相应的数据(m_Data)我调用处理资源的方法:((IDisposable*)pCurrent->m_Data)->Dispose();
• 这个调用之后是一个delete pCurrent->m_Data显然尝试调用~IBase()哪个不明显存在,因为它是一个接口.因此,所提到的~Derived()也不会被调用,并且任何智能指针Derived也不会被删除,这会导致严重的内存泄漏.

令人惊讶的是手动删除工作:

auto p = new Derived();
delete p; // ~Derived() is properly called as we are …

我想我误解了C++继承的东西.

假设我有这种经典继承:

    class A{
    public: 
        virtual void method1() =0;
        virtual ~A() = default;
    }

    class B : public A{
    public :
        void method1(){doSomething();}
    }

    class C : public A{
    public :
        void method1(){doSomethingElse();}
    }

如何让其他Q类拥有B或C类型的对象,而不事先知道它是哪种类型？(我的意思是我们知道它是A型)

谢谢阅读 !

using namespace std;

class A {};

class B {};

class C : public A {
    public:
    C(){ b = new B();}
    B* b;
    ~C(){
        printf("in destructor\n");
        delete b;
    }
};

void doSomething(A&aref)
{
    C c = (C &) aref;
    c.b = new B();
    int i;
}

int main()
{      
    A * a;

    a = new C();
    printf("Line 1\n");
    doSomething(*a);
    printf("Line 2\n");

    delete(a);

    return 0;
}

输出为：

Line 1
in destructor
Line 2

尝试删除delete(a)并获得相同的结果。

为什么我看不到析构函数两次调用？我希望可以在doSomething函数末尾和delete调用时调用它。 …

在将C ++强制转换为派生类之后，我遇到了一些奇怪的事情。这是问题的简化：

class animal{
public:
    animal(){
        _name="animal";
    }
    virtual void makenoise(){
        cout<<_name<<endl;
    }
    T get_name(){
        return _name;
    };
protected:
    T _name;
};

class cat:public animal{
public:
    cat(){
        this->_name="cat";
    }
private:
};

class dog:public animal{
public:
    dog(){
        this->_name = "dog";
    }
};

如果我按照以下方式进行动态投射，则可以正常工作。

vector<animal*> barnyard;
barnyard.push_back(new animal());
barnyard.push_back(new dog());
barnyard.push_back(new cat());
dog* dogptr = dynamic_cast<dog*>(barnyard[1]);
barnyard[1] = dogptr;
cout<<barnyard[1]->get_name()<<endl;

但是可以通过以下方式进行：

 for (int ii=0;ii<3;ii++) {
        if (barnyard[ii]->get_name()=="cat"){
            auto dogptr = dynamic_cast<dog*>(barnyard[ii]);
            barnyard[ii] = dogptr;
            cout<<barnyard[ii]->get_name()<<endl;
        }
    }

给出细分错误。任何的想法？

在基类构造函数中，我希望实例是派生类。我可以做这样的事情吗？

class InterfaceClass // Final user only sees this class
{ 
    enum class TYPE 
    {
        CHILDONE
    };

public:
    InterfaceClass(TYPE);
    virtual void hello_world() = 0;
    virtual void print_class();
};

class ChildOne : public InterfaceClass 
{
public:
    ChildOne() = default;
    void hello_world();
private:

};

InterfaceClass::InterfaceClass(TYPE type) 
{
    if (type == CHILDONE)
        this = new ChildOne();
    else
        throw "NOT HANDLED";
}

void InterfaceClass::hello_world() {
    std::cout << "Hello world from InterfaceClass" << std::endl;
}

void InterfaceClass::print_class() {
    std::cout << "Not implemented" << std::endl;
} …