1回答
根据准则：
如果需要默认析构函数，但其生成已被抑制(例如，通过定义移动构造函数)，则使用=default。
我无法想象在类中，如果没有显式默认析构函数，代码什么时候会出现错误，而类中有移动构造函数。
有人能给我举个例子证实上面的话吗？
struct S {
S() {};
S( S&& ) {}; // move ctor
};
int main() {
S s; // there is no need to declare dtor explicitly =default
}
浏览 2提问于2015-10-21得票数 11
回答已采纳
1回答
我正在阅读教科书"C++ Primer Plus，Prata“
第10章中有一段引起了我的注意，使我感到困惑。
Ch.10对象和类：
上面写着
如果不提供one，编译器将隐式声明默认的构造函数，
我觉得应该是
如果不提供析构函数，编译器将隐式声明默认的析构函数，
这段是对的吗？
我该如何正确解释呢？
谢谢
浏览 4提问于2016-02-16得票数 1
回答已采纳
假设我有：
class Base {
public:
virtual ~Base() = 0;
}
class Derived: public Base {
public:
~Derived();
}
在我的代码中，我需要通过一个Derived指针删除Base类，如下所示：
delete[] pt_base;
但是，在已实现的析构函数中，我实际上没有任何要销毁的东西。但我仍然需要他们通过基类删除？
在不浪费大量代码和空析构函数的情况下，实现我想要的东西的最佳方法是什么？
浏览 11提问于2014-12-01得票数 0
回答已采纳
删除链接列表中的节点时，是否需要将next设置为NULL？
ListNode被定义为
struct ListNode {
int val;
ListNode* next;
ListNode(int x): val(x) {}
}
现在我想删除m之后的节点
ListNode *tmp = m->next;
m->next = m->next->next;
delete tmp;
如果要删除析构函数中的tmp->next，则链接列表将遇到麻烦。但是，如果不删除tmp->next，可能会有另一种情况导致内存泄漏：
ListNode *tmp
浏览 3提问于2016-09-21得票数 0
回答已采纳
假设我们有三门课:父母，孩子和其他。
class Parent: {
public:
Parent(std::string title): m_title(title) { }
void setTitle (std::string title);
private:
std::string m_title;
};
class Child: public Parent {
public:
Child(std::string title) { setTitle(title); }
private:
Other object;
};
class Other
浏览 6提问于2013-09-05得票数 1
回答已采纳
2回答
即使我在C++中重新定义了一个类的析构函数，也可以调用默认的析构函数吗？例如，如果我有两个类
class B{
...
};
class A{
private:
B* p;
public:
A(B b):p(new B(b)){...}
...
~A(){delete p;}
};
我并不总是想删除p指向的对象。
浏览 1提问于2015-01-24得票数 0
一个什么都不做的虚拟析构函数是
virtual ~ClassName() {}
自从C++11
virtual ~ClassName() = default;
这两者有什么区别吗？
浏览 1提问于2017-07-03得票数 9
回答已采纳
2回答
我写了下面的程序
#include <iostream>
#include <stdexcept>
class Myclass
{
public:
~Myclass()
{
//throw std::runtime_error("second (in destructor)");
throw 1;
}
};
void fun()
{
Myclass obj;
}
int main()
{
try
{
fun();
}
浏览 1提问于2017-04-18得票数 7
回答已采纳
在下面的代码中，类C中的对象sub被构造了两次。第一个构造调用默认的ctor Sub()，第二个构造使用placement new在相同的地址中重新构造这个对象。
因此，析构函数也会被调用两次。第一个调用使用~C()中对Sub数据函数的直接调用，第二个调用是在main()结束后由atexit()函数调用的。
假设对象sub是在相同的地址重新构造的，编译器如何知道第二个析构函数必须在main()之后调用？他把这些信息放在哪里？
#include <iostream>
using namespace std;
struct Table
{
int i;
Table(i
浏览 0提问于2012-01-18得票数 0
回答已采纳
1回答
作为一个学生，在过去的一年，我与GCC 4.4.7合作编译C++代码，如果没有在代码中明确定义它们，它将为我的类创建构造函数和析构函数。这是4.2.x版本中存在的特性吗？
在你问我之前，是的，我在谷歌上搜索过这个，看过gcc.gnu.org，但是我的搜索没有发现任何结果。
浏览 2提问于2015-07-17得票数 0
回答已采纳
3回答
我在一个类中声明了一个结构的向量。我的问题是，我是必须显式地释放由类析构函数中的向量分配的内存，还是在销毁实例时自动释放。同样，我是否必须在类析构函数中包含代码来释放向量的内存。
浏览 3提问于2013-06-24得票数 0
回答已采纳
2回答
C++内置析构函数编译警告
、、、、
我在代码中使用了一个内置析构函数，类似于这段被剥离的代码：
#include <new>
#include <stdlib.h>
struct Node {
};
int main(int, char**) {
Node* a = reinterpret_cast<Node*>(malloc(sizeof(Node)));
new(a) Node;
Node* b = a;
b->~Node();
free(a);
}
不幸的是，这给了我在Visual 2015中的一个警告，无论是在调试还是发布中：
浏览 2提问于2017-01-03得票数 7
回答已采纳
3回答
我的问题很简单，但我在任何地方都找不到问题。
如果我有一个这样的类
class A {
vector<int> data;
}
当A的实例被销毁时，data也会被销毁吗?或者我应该为A编写一个析构函数来调用data的析构函数吗?基本上我担心当A的实例被销毁时，向量的动态内存是否不会被释放。我怀疑答案是data被正确地释放了，但我不想以一种艰难的方式发现我错了。
此外，如果A是一个结构，当data的本地实例超出作用域时，会调用A的析构函数吗？
浏览 3提问于2012-02-29得票数 15
回答已采纳
1回答
使类抽象是通过使其成员函数之一成为纯虚拟函数。
使类抽象要求类的子类实现基纯虚函数。
我们甚至可以将基类析构函数变为纯类，这足以成为抽象类。
问题是：
为什么我们没有义务在派生类中实现纯虚拟基的析构函数？
这是否意味着只要C++在默认情况下向我们添加四个成员函数:构造函数、复制构造函数、赋值函数和析构函数，我们就不需要在派生类中实现它？
例：
#include <iostream>
using namespace std;
class Base
{
public:
Base(){cout << "Base Ctor
浏览 0提问于2016-11-14得票数 1
回答已采纳
我使用的结构涉及到一些POD和UnicodeString，例如
struct TMyStruct
{
int value1;
bool value2;
UnicodeString mystring;
}
现在，为了将其转换为数组，我使用std::vector
std::vector<TMyStruct> myarray;
myarray.push_back(TMyStruct());
... etc.
我想知道我是否需要更多的东西才能像这样使用它-比如UnicodeString部件的复制构造函数，深度复制，结构的析构函数等等，或者上面的内容足以将UnicodeString用作结构数
浏览 0提问于2012-10-19得票数 1
回答已采纳
2回答
这是我在pimpl中使用unique_ptr时所看到的一个简化。我选择unique_ptr是因为我真的想让类拥有指针--我希望pimpl指针和类的生命周期是一样的。
无论如何，这是头文件：
#ifndef HELP
#define HELP 1
#include <memory>
class Help
{
public:
Help(int ii);
~Help() = default;
private:
class Impl;
std::unique_ptr<Impl> _M_impl;
};
#endif // HELP
以下是源代码：
浏览 1提问于2012-01-26得票数 62
回答已采纳
4回答
我是C++的新手。据我所知，与java不同，C++没有自动垃圾处理功能，因此我们在类中为对象添加了析构函数：
class A{
class A();
~class A(); // destructor
};
我很好奇当我们使用structs时会发生什么。另外，当我们不向类添加析构函数时会发生什么？内存是如何释放的？
浏览 0提问于2013-03-10得票数 1
1回答
我将基类的去除器定义为"Virtual“。例如：-
class Base
{
public:
virtual ~Base()
{
cout << "Calling ~Base()" << endl;
}
};
在派生类中也是如此，例如：
class Derived: public Base
{
public:
virtual ~Derived()
{
cout << "Calling ~Derived()" << endl;
}
浏览 2提问于2013-07-08得票数 3
或者你必须手动创建它们吗？我想知道你是否可以创建一个类，声明一些变量和方法/函数。然后在int main函数中将该对象分配给您的类。您是否需要放入构造函数/解构函数来创建和销毁用于保存变量位置的内存，或者是否已有默认设置可以做到这一点？任何关于构造函数和析构函数的附加信息都会很好。不需要太多，只需要一些简单的补充信息就可以更容易地理解这一点。不尝试创建会导致内存泄漏的程序
浏览 1提问于2014-04-09得票数 1
C++编译错误消息中的__tpdsc__是什么意思？例如：
[ilink32 Error] Error: Unresolved external '__tpdsc__ ELicense' referenced from LICENSE.OBJ
我使用CLANG作为C++编译器。
我问的是tpdsc是什么意思，而不是“未解决的外部”是什么意思，因为它很清楚。tpdsc是编译器添加的东西，我想知道它是什么意思。
我的代码是：
class PACKAGE ELicense: public Exception
{
public:
ELicense(in
浏览 2提问于2016-08-13得票数 2
1回答
我有一堂课如下：
#include <iostream>
#include <type_traits>
#include <concepts>
#include <vector>
class Foo
{
public:
Foo( )
: m_member1( 1 ), m_member2( 2 ), m_member3( std::vector<char>( 1 * 2, '-' ) )
{
}
// ~Foo( ) is not defined (i.e. implicit
浏览 1提问于2022-01-15得票数 0
回答已采纳
1回答
编辑：在示例类中添加了一个字段，使其不可破坏，并澄清了它并不是问题的重点。
考虑一个没有用户声明的析构函数的简单类。
struct A {
std::string s;
};
注意，实际的字段并不重要--它只是为了使类不可破坏，这样才不会分散注意力。换句话说，想象一下这是一个“正常”的日常课程，在任何方面都不例外。
在本例中，编译器将为我们生成析构函数。总的问题是:这个析构函数是什么时候产生的，它的主体放在哪里？
更具体而言：
编译器实际生成任何源代码吗？如果是的话，这个源代码放在哪里？
如果没有生成实际的源代码，并且我们直接转到一些内部表示/机器代码，那么问题是相同的--什么
浏览 0提问于2021-11-23得票数 2
回答已采纳
1回答
在下面的代码中，我们在delete函数中将删除节点的下一个指针初始化为NULL，那么为什么我们需要在类中显式定义析构函数，编译器自动生成的默认析构函数是否存在问题？我们知道析构函数会删除对象，而不会为它编写任何额外的代码，为什么我们在这里为析构函数编写额外的代码。在delete部分，我们必须处理被删除的节点不应该指向任何东西，我们这样做了。
那么，有什么需要显式声明其中的析构函数呢？
class Node {
public:
int data;
Node* next;
//constructor
Node(int data) {
thi
浏览 4提问于2022-10-10得票数 0
1回答
我有一个带有链接的哈希表，每个节点都在其中：
struct Node
{
Object * objPtr;
Node * next;
}
当我从文件中读取数据时，我创建了一个对象：
...
Object * currObj;
currObj = new Object; //Causes memory leaks (doesn't get deleted)
//Save data
currObj->setData(data);
//Insertion
insert(*currObj);
在这种情况下，正确的破坏者是什么？我有表的析构函数和对象的析构函数，但是cur
浏览 1提问于2017-05-22得票数 0
2回答
这里是我的代码:
#include <iostream>
using namespace std;
class new_class{
public:
new_class();
float multiplication(){return x*y;}
~new_class();
private:
float x;
float y;
};
int main()
{ new_class class_11;
cout<<class_11.multiplication()<<endl;
system(&
浏览 1提问于2011-04-19得票数 1
4回答
继承和编译器生成的函数
、、、
当我有继承时，我通常得到的编译器生成的函数(构造函数、析构函数、赋值操作符和复制构造函数)是否仍然为我的类生成？
假设我有这样的继承:一个基类，一个继承A ( public )的B和C，它继承了B。我的A类没有内存分配，或者任何需要由我实现析构函数的东西，而且我没有在那里实现析构函数，当我编译我的程序时，它还会创建空的A::~A(){}吗？
B和C也一样。谢谢!
浏览 4提问于2015-06-25得票数 1
回答已采纳
2回答
我有一个很大的程序，有些类使用指针到成员函数.一般的代码结构是：
#include <iostream>
using namespace std;
/**** CLASS FOO ****/
class Foo {
public:
Foo(); //constructor
void F
浏览 3提问于2015-03-18得票数 1
回答已采纳
1回答
我正在编写一个C++库，并希望它的一个类被隐式共享。不幸的是，我有点混淆了它的实现。我想使用std::shared_ptr来存储数据，我想知道下面的代码是否遗漏了什么。
// MyClass.h
class MyClass
{
public:
MyClass (void);
private:
class Data;
std::shared_ptr<Data> mData;
};
// MyClass.cc
class MyClass::Data
{
public:
Data (void) { ptr = NULL; }
~Data (v
浏览 2提问于2014-09-08得票数 0
5回答
我搞错了，我完全不知道为什么..。我已经搜索过这个网站了，什么也找不到.
我的错误是：‘int 2019:未解决的外部符号“公共：__thiscall活动：：~运动(无效)”(？？1 __thiscall @QAE@XZ)在“公共：__thiscall销售:销售”( int，class agent，class活动)中引用
这是我的代码：
#include "stdafx.h";
#include <iostream>
#include "campaign.h";
//constructor
campaign::campaign()
{
ca
浏览 3提问于2013-08-02得票数 1
回答已采纳
3回答
我正在C++上进行一些在线测试，下面是我遇到的问题。
class A
{
public:
A(int n = 2) : m_i(n) { }
~A() { std::cout << m_i; }
protected:
int m_i;
};
class B
: public A
{
public:
B(int n) : m_a1(m_i + 1), m_a2(n) { }
public:
~B()
{
std::cout << m_i;
--m_i;
}
priv
浏览 2提问于2015-05-22得票数 2
回答已采纳
1回答
这可能是一个简单的问题，但是:如果程序使用delete操作符，是否不需要析构函数？这是在"C++“中。
浏览 0提问于2013-06-18得票数 1
回答已采纳
1回答
类似 的类 是以匿名联合作为 直接成员的联合或类。类似于联盟的类 X 有一组 变体成员。如果 X 是一个联合，则非匿名联合的 X 的非静态数据成员是 X的变体成员。此外，作为 X 成员的匿名联合的非静态数据成员也是 X的变体成员。[ 示例：
在下面的第一个例子中，类C 不是一个类似于联合的类，但是我们可以说联合子对象u的成员是C的变体成员吗？如果答案是肯定的，为什么？
struct C{
int i;
union{
int x;
char c;
float f;
} u;
};
在我的第二
浏览 1提问于2019-04-05得票数 0
回答已采纳
我有一个A类。A有自己的析构函数。
我使用A定义B，如下所示。
class A{
protected:
int* array;
public:
A(int size){array = new int[size];}
~A() { delete [] array;}
}
class B{
public:
A x;
}
我应该如何定义B的析构函数
提前谢谢。
浏览 0提问于2013-03-08得票数 1
假设我有一堂课
class A {
public: // I know, I know...
shared_ptr<string> aString;
};
我必须有一个破坏者像
~A() {
aString.reset();
}
以确保所有权得到适当的解除？我做了几次测试，而且似乎不需要--也就是说，当A的实例超出范围或被删除(或者重置，如果我通过shared_ptr引用它)，字符串也会被删除(我使用了一个更复杂的示例来证实这一点)。但是，这可能是特定于我正在使用的编译器的实现(clang-700.0.72)。
我的问题是:这种情况总是这样吗，还是像删除任何其他哑指
浏览 7提问于2015-10-12得票数 4
回答已采纳
下面的代码是用Visual 2019编译的，而不是用gcc和clang编译的。定义变量b会导致后两个编译器出现错误。
#include <iostream>
class base
{
public:
constexpr base(int i) : m_i(i) {}
constexpr int i() const { return m_i; }
protected:
~base() = default; // Forbid polymorphic deletion
private:
const int m_i;
};
class derive
浏览 2提问于2021-11-09得票数 4
回答已采纳
如果我有以下声明：
#include <iostream>
#include <string>
class DEMData
{
private:
int bitFldPos;
int bytFldPos;
std::string byteOrder;
std::string desS;
std::string engUnit;
std::string oTag;
std::string valType;
int idx;
public:
DEMData();
DEMData(const D
浏览 2提问于2010-03-03得票数 20
回答已采纳
1回答
虽然对构造函数使用=default对我来说是明确的(例如，在存在其他函数时，强制编译器创建默认构造函数)，但我仍然无法理解这两种类型的析构函数之间的区别：
使用=默认的
未显式定义并由编译器自动生成的。
我想到的唯一一件事是，Grou-1析构函数可以定义为虚拟的，但是group-2总是非虚拟的。所以，这是他们之间唯一的区别吗？是否有编译器没有生成析构函数，但使用=default强制编译器生成它的情况？
附注：我检查了很多堆叠溢出的Q，但没有一个回答我的问题。下面是一些相关问题。
编辑1: on SO，重点是禁用默认的移动构造函数，该构造函数可以被视为
浏览 0提问于2019-06-27得票数 5
回答已采纳
5回答
在C++中，您可以声明很多东西为：变量、函数(包括成员函数和运算符)、构造函数，以及自C++1z、以及和。但是，声明一个 constexpr会导致一个错误：
struct X {
constexpr ~X() = default; // error: a destructor cannot be 'constexpr'
};
我的问题：
为什么不能将析构函数标记为constexpr
如果不提供析构函数，则隐式生成析构函数constexpr吗？
如果我声明一个默认析构函数(~X() = default;)，它是否自动constexpr？
浏览 3提问于2017-07-13得票数 39
回答已采纳
我基本上有这样的东西：
class CGlToolBase
{
public:
CGlToolBase(void)
{
}
virtual void OnMouseDown(CGlEngine &glEngine, WPARAM wParam, LPARAM lParam);
virtual void OnMouseMove(CGlEngine &glEngine, WPARAM wParam, LPARAM lParam);
virtual void OnMouseUp(CGlEngine &glEngine, WPA
浏览 3提问于2010-08-01得票数 2
回答已采纳
在以下简单代码片段中：
#include <cstddef>
struct B
{
virtual ~B() = default;
static void operator delete(void *, int);
static void * operator new(size_t, int);
};
struct C : B
{
virtual ~C() = default;
};
Clang3.7抱怨“未删除的函数'~C‘不能覆盖已删除的函数”：
Visual和GCC都不报告此代码中的错误。是嘎嘎的缺陷还是什么？
浏览 0提问于2015-11-10得票数 7
回答已采纳
我猜这个网站上的某些人似乎认为这个问题已经在其他地方得到了回答。无论如何，我自己想出来了，我所要做的就是在解决方案资源管理器的源文件部分中包含"EmployeeRecord.cpp“文件……现在我有了另一个问题，所以我将留下这个问题的答案，并在其他地方询问它。
头文件：
/*******************************************************************
* File: EmployeeRecord.h
* Name: You don't need this
* Assignment 1: Employee Rec
浏览 1提问于2015-02-09得票数 0
5回答
我目前正在编写一个具有以下多态层次结构的程序: Base: Multinumber。派生:对，复数，有理。Multinumber是一个虚拟类，从不实例化。
在我的程序过程中，我经常动态地管理基类，所以我需要一个析构函数。我的问题是:如何使析构函数成为虚拟的？在我的Multinumber.h文件中，我现在有：
virtual ~Multinumber();
在我的Multinumber.cpp中：
Multinumber::~Multinumber()
{
}
在我所有的派生类中，我都有：
Rational::~Rational()
{
}
我的任何派生.h文件中都没有任何内容。不幸的是，这
浏览 2提问于2010-12-04得票数 2
回答已采纳
3回答
我有一个子构造函数，如下所示：
Child():Parent(){
}
所以孩子的析构函数是：
~Child(){
}
并且父母有类似的东西：
Parent(){
abc.Construct();
}
~Parent(){
abc.Destruct();
}
如何确保在销毁子对象的过程中，在初始化(在Parent()构造函数中)进行的所有分配都被删除？
浏览 2提问于2013-11-20得票数 0
我对一些boost特性还不熟悉，我还面临一些问题，试图将引用转换为boost::any对自定义类的引用(目前它是空的，我仍然在计算类的内容)。
很快，我就会：
class MyClass
{
public:
MyClass();
~MyClass();
private:
}
MyClass function(boost::any &source)
{
if (source.type() == typeid(MyClass))
return boost::any_cast<MyClass>(source);
}
我还没有实现构造函数和
浏览 1提问于2018-06-21得票数 1
4回答
可能的重复：
编译器不强制Child class在其Base具有纯virtual析构函数时实现析构函数。
struct Base
{
virtual void foo () = 0;
virtual ~Base() = 0;
};
Base::~Base() {} // necessary
struct Child : Base
{
void foo() {}
//ok! no destructor needed to create objects of 'Child'
};
有趣的是，编译器宁愿强迫Base定义析构函数体。。(供参考)
那么，在类
浏览 4提问于2011-07-28得票数 20
回答已采纳
让我们考虑下面的示例(使用c++11)
A.hpp：
#include <memory>
class A
{
public:
//A();
//~A();
private:
struct AImpl;
std::unique_ptr<AImpl> pImpl;
};
main.cpp：
#include "A.hpp"
int main()
{
A a;
}
使用默认构造函数和析构函数。不编译。发生以下错误：
在/usr/include/c++/4.8/内存中包含的文件:81:0，来自A.hpp:2，
浏览 1提问于2014-02-11得票数 10
回答已采纳
默认析构函数可以自动生成为虚拟析构函数吗？
如果我定义了一个基类，但没有默认的析构函数，是否会自动生成一个默认的虚拟析构函数？
浏览 11提问于2009-07-13得票数 60
回答已采纳
1回答
假设我有一个这样的班级：
class example{
double * ptr;
public:
example();
~example();
};
实施了以下方法：
example::example(){
ptr = new double;
*ptr = 0;
}
example::~example(){delete ptr;}
如果我主要创建一个std::vector<example> v;和v.push_back(example());，我只会得到一个由于无效删除引起的分段错误。我不太清楚是什么导致了这件事，
浏览 3提问于2019-11-24得票数 0
回答已采纳
我正在尝试编写一个单元测试，以检测我的类的lock()特性的无效使用。为了做到这一点，我想使用析构函数并从那里抛出一个异常。不幸的是，g++没有捕获异常，而是决定调用std::terminate()。
这个类有一个非常简化的版本：
class A
{
public:
A() : f_lock(0) {}
~A() { if(f_lock) throw my_exception("still locked"); }
lock() { ++f_lock; }
unlock() { --f_lock; }
private:
int f_lock
浏览 1提问于2014-10-13得票数 6
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
