我试着理解在退出范围时析构函数调用的顺序。假设我有以下代码:
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 A{
public:
~A() {
//do something
}
};
class B: public A{
};
class C: public A{
};
class D: public A{
};
现在,我希望B、C和D具有与A相同的析构函数。
在“加速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
下列代码按预期工作:
// ./mwe/index.js
let foo = () => 'foo';
const Bar = {
foo
};
export default Bar;
// ./index.js
import Bar from './mwe';
console.log(Bar); // logs an object with a member foo that is a function
然而,这是行不通的:
// ./index.js
import {foo} from './mwe';
console
如果我有以下课程:
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也使用动态内存,这是我
标准列举了以下例子(3.8/7 N3797):
struct C
{
int i;
void f();
const C& operator=( const C& );
};
const C& C::operator=( const C& other)
{
if ( this != &other )
{
this->~C(); // lifetime of *this ends
new (this) C(other); // new object of type C cr
什么时候类的非指针成员被析构?示例:
class foo {
private:
int a;
public:
foo(int sa):a(sa){}
~foo(){}//does anything need to be done here?
};
{
foo(10);
}//the destructor is called
在析构函数中应该做些什么吗?谢谢!
以下节目:
#include <iostream>
using namespace std;
class Test
{
public:
Test() { cout << "Constructor is executed\n"; }
~Test() { cout << "Destructor is executed\n"; }
};
int main()
{
Test(); // Explicit call to constructor
Test t; // local object
在本例中链接..。
我发现了一些章节,比如,~ImprovedClass() ~Inner()
请帮帮我,他们是什么?为什么和如何在代码中使用它们?
class Inner
{
public Inner(IntPtr unkOuter)
{
}
~Inner()
{
}
}
public class Improv
给定一个代码(真正的伪代码):
struct A { /* ... */ }; // assume is non-trivial
struct B { /* ... */ }; // assume is non-trivial
using UA = std::unique_ptr< A >;
using UB = std::unique_ptr< B >;
union U
{
UA a;
UB b;
};
U u{std::make_unique< A >(/* init */)};
u.a = nullptr; // destru
请考虑以下几点
class base{
base();
~base();
}:
class derived : public base{
};
当派生对象被析构并且派生类没有定义析构函数时,是否会自动调用基类析构函数?
否则,如果我在派生类中也有析构函数,我是否也需要显式调用基类析构函数?
class base{
base();
~base();
}:
class derived : public base{
derived();
~derived
base::~base(); //do I need this?
我有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;
我怀疑有一些角落的情况下,~
我有一个三层深的类层次结构,如下所示:
class A {
public:
virtual ~A() {}
}
class B : public A {
public:
virtual ~B() {}
void foo(E *e) {
e->remove(this);
}
}
class C : public B {
public:
~C() {}
}
class E {
public:
void remove(A *a) {
delete a;
}
}
我想知道的是,当我在C的对象上调用f
......\node_modules\koa\lib\response.js:47
const { res } = this;
^
SyntaxError: Unexpected token {
at exports.runInThisContext (vm.js:53:16)
at Module._compile (module.js:373:25)
at Object.Module._extensions..js (module.js:416:10)
at Module.load (module.js:343:32)
at Funct