在“加速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
我想知道为什么委员会决定在定义析构函数时隐式删除移动构造函数。
#include <iostream>
#include <vector>
#include <memory>
struct A {
~A(){};
std::unique_ptr<int> a;
};
int main()
{
A a;
A b = std::move(a);
}
对于“不默认移动成员”这一规则,有什么专题用例是合理的吗?
标准列举了以下例子(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
以下节目:
#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
假设我创建了一个自定义的Array类,并具有以下构造函数:
Array::Array(size_t size)
{
mySize = size;
//myData is of type int*
myData = new int[mySize]; // this stuff is allocated on a heap
}
据我所知,本例中的默认复制构造函数将实现为:
Array::Array(Array& a)
{
mySize = a.mySize;
myData = a.myDat
我正在调用析构函数来释放内存,但它没有删除我的对象。背后的原因是什么?
我的代码是这样的:
class A
{
public:
int a;
A()
{
cout << "a" << endl;
}
};
class B :public A
{
public:
int b;
B()
{
cout << "b" << endl; a = 10; b = 20;
}
~B()
{
cou
给定一个代码(真正的伪代码):
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
我正在使用SDL在c++中制作一个游戏。我有一个main函数,它只调用run游戏函数。运行游戏函数运行游戏,并在退出时返回0。我尝试在每次调用之前和之后打印内容,seg错误应该在返回0时发生;
functioncall()
{
Loads of SDL and other stuff
SDL_Quit();
gamestatemanager.~Gamestatemanager();
return 0; // This is probably where i get the seg fault
}
int main()
{
A* x = new B(10, 20);
x->opt1();
delete x;
return 0;
}
int main()
{
B x(10, 20);
return 0;
}
第一个是内存泄漏,因为x是一个指向B对象的A对象。如果A不是指针,它还会有内存泄漏吗?
为什么第二个函数没有内存泄漏呢?我们不需要删除x?
class A
{
private:
int* a;
public:
A(int size) {
a = new int
请考虑以下几点
class base{
base();
~base();
}:
class derived : public base{
};
当派生对象被析构并且派生类没有定义析构函数时,是否会自动调用基类析构函数?
否则,如果我在派生类中也有析构函数,我是否也需要显式调用基类析构函数?
class base{
base();
~base();
}:
class derived : public base{
derived();
~derived
base::~base(); //do I need this?