我使用g++ -Wall -Werror *.cpp编译并获得错误:
ConcreteCharArray.h:21:15: error: declaration of ‘~CharArray’ as member of ‘ConcreteCharArray’
具体执行情况:
class ConcreteCharArray: public CharArray
{
private:
char * charArray;
public:
~CharArray() {
delete[] string;
}
};
虚拟课程:
class CharArray
{
public
我对虚拟析构函数感到困惑。我读了很多问题和解释,但我仍然不明白,如果基类有一个派生类,即使它没有任何特殊操作,我也需要实现它自己的析构函数。
编译器会编译下面的代码,但是会不会有任何内存泄漏或任何问题?
Class Base{
public:
virtual ~Base(){}
};
Class Derived : public Base{
// do i need a special destructor here for Derived ?
}
Base *foo;
foo = new Derived;
delete foo;
我读到析构函数不能共享,这是真的吗?
我有一个带有几个子类的基类,这些子类的析构函数不会改变。这将导致一些重复的代码。
可以共享析构函数吗?如果没有,我该如何避免这些析构函数中的重复代码呢?
Class A{
public:
~A() {
//do something
}
};
class B: public A{
};
class C: public A{
};
class D: public A{
};
现在,我希望B、C和D具有与A相同的析构函数。
请考虑以下几点
class base{
base();
~base();
}:
class derived : public base{
};
当派生对象被析构并且派生类没有定义析构函数时,是否会自动调用基类析构函数?
否则,如果我在派生类中也有析构函数,我是否也需要显式调用基类析构函数?
class base{
base();
~base();
}:
class derived : public base{
derived();
~derived
base::~base(); //do I need this?
我使用boost.python来编写用c++编写的python模块。我有一些带有纯虚拟函数的基类,我导出了这样的函数:
class Base
{
virtual int getPosition() = 0;
};
boost::python::class_<Base>("Base")
.def("GetPosition", boost::python::pure_virtual(&Base::getPosition));
在Python中,我有代码:
class Test(Base):
def GetPosition(s
假设我有:
class Base {
public:
virtual ~Base() = 0;
}
class Derived: public Base {
public:
~Derived();
}
在我的代码中,我需要通过一个Derived指针删除Base类,如下所示:
delete[] pt_base;
但是,在已实现的析构函数中,我实际上没有任何要销毁的东西。但我仍然需要他们通过基类删除?
在不浪费大量代码和空析构函数的情况下,实现我想要的东西的最佳方法是什么?
当一个类的dtor为空时,当它自己的dtor从联合中显式调用时,它会调用成员的dtor吗?
这是一种困难的文字,希望伪代码是更直接的。在本例中,Texture::~Texture()是否会隐式调用source.bitmap.pixels.~vector()?
struct Bitmap{
~Bitmap(){} // empty dtor
// members
std::vector<uint8> pixels; // <-- will this dealloc when ~Bitmap() is called manually?
};
stru
根据准则:
如果需要默认析构函数,但其生成已被抑制(例如,通过定义移动构造函数),则使用=default。
我无法想象在类中,如果没有显式默认析构函数,代码什么时候会出现错误,而类中有移动构造函数。
有人能给我举个例子证实上面的话吗?
struct S {
S() {};
S( S&& ) {}; // move ctor
};
int main() {
S s; // there is no need to declare dtor explicitly =default
}
我试着理解在退出范围时析构函数调用的顺序。假设我有以下代码:
class Parent{
Parent(){cout<<"parent c called \n";}
~Parent(){cout<< "parent d called \n";}
};
class Child: public parent{
Child(){cout<< "child c called \n";}
~Child(){cout<<"child d called\n";}
};
现在,我知道子构造函数
如果我有以下课程:
class Small {
public:
Small();
Small(const Small &small);
~Small();
private:
int *arr;
};
和
class Big {
public:
Big();
Big(const Big &big);
~Big();
private:
char *name;
Small smallObject;
};
当我调用~Big()时,我会删除分配给name成员的动态内存,但是smallObject也使用动态内存,这是我
为什么在下面的例子中都调用了析构函数,~D(),~C(),~B(),~A()?
只有一个虚拟析构函数:A的那个。
代码如下:
#include<iostream>
using namespace std;
class A
{
public:
virtual ~A()
{
cout<<"destruct A\n";
}
};
class B:public A
{
public:
~B()
{
cout<<"destruct B\n";
}
};
class C:public B
{
pu
得到一些错误,认为它是一个带有非虚拟析构函数的虚拟函数。如何修复此错误?它在g++ 4.6.x中工作,但我需要它在旧版本的g++上工作。:(
#include <list>
template <typename T>
class container{
public:
~queue(){
queuel.clear();
queuel.~list();
}
virtual T func_x(){
T temp;
//do stuff with list<t> test
考虑一个简单的接口/实现设计:
class Base
{
public:
virtual ~Base()
{
// Virtual empty destructor
}
};
class Derived : public Base
{
public:
virtual ~Derived()
{
// Lots of clean up code here
// ...
}
};
使用此设计,我理解以下代码是安全和有效的:
Base* base = new Derived();
delete bas
我有一个struct O,用第三方代码定义。因为它是C代码,所以它不定义virtual destructor。(在我的例子中,它是来自OVERLAPPED struct的win32 appi)。
我正在修改的客户代码有一个class S,它来自class A,来自struct O。
struct O{};
class A : public O{};
class S : public A{};
他们中没有人将其析构函数声明为virtual。
如果在指向delete的指针上调用O,则会出现泄漏。好的。
但是,如果我曾经在指向S的指针上调用delete,那么delete标准会指出什么呢?它是否会自动
我用的是gcc。我知道当我们销毁基类指针指向的派生类对象时,虚析构函数是如何解决这个问题的。我想知道它们是如何工作的?
class A
{
public:
A(){cout<<"A constructor"<<endl;}
~A(){cout<<"A destructor"<<endl;}
};
class B:public A
{
public:
B(){cout<<"B constructor"<<endl;}
在“加速C++”的第11章中,作者提出了一个用数组模拟std::向量行为的向量类。他们使用分配程序类来处理内存管理。uncreate函数的作用是销毁数组的每个元素并释放分配给数组的空间:
template <class T> void Vec<T>::uncreate() {
if (data) {
// destroy (in reverse order) the elements that were constructed
iterator it = avail;
while (it != data)
alloc.destroy(--it
出于好奇,我试着做一些类似下面的例子,看看编译器是否给了我一个警告,而不是调用一个无穷无尽的循环,最终导致堆栈溢出。我想也许有一种不同的行为,而不仅仅是调用普通的函数或方法。但事实并非如此。有什么特别的解释吗?或者它只是作为普通的函数调用来处理,因为我是使用this操作符显式地调用基类析构函数?
示例:
class A {
virtual ~A();
};
class B : A {
virtual ~B() { this->~A(); }
};
我有Y型的类层次结构: C类继承A和B,D类继承C,A和B有虚拟析构函数,C的析构函数不是虚拟的。我知道,如果没有双重继承(比方说没有B),那么C()将是虚拟的。我的问题是双重继承会影响它吗?
class A { virtual ~A(); ...};
class B { virtual ~B(); ...};
class C : public A, public B { ~C(); ...};
class D : public C { virtual ~D(); ... };
我必须通过指向C的指针删除D类的实例。
C* c = new D;
delete c;
我怀疑有一些角落的情况下,~