标签: object-destruction

有效的Java说:

使用终结器会严重影响性能.

为什么使用终结器破坏对象的速度较慢？

这主要是出于好奇.

如果有人遇到Object.finalize()的任何良好用法,除了调试/记录/分析目的外,我还在徘徊？

如果你没有遇到任何你会说好的用法会是什么？

我有一个主程序(main.cpp)和一个共享库(test.h和test.cpp):

test.h:

#include <stdio.h>

struct A {
    A() { printf("A ctor\n"); }
    ~A() { printf("A dtor\n"); }
};

A& getA();

TEST.CPP:

#include "test.h"

A& getA() {
    static A a;
    return a;
}

main.cpp中:

#include "test.h"

struct B {
    B() { printf("B ctor\n"); }
    ~B() { printf("B dtor\n"); }
};

B& getB() {
    static B b;
    return b;
}

int main() {
    B& b = getB();
    A& a = getA();
    return 0;
}

这是我在Linux上编译这些源代码的方法:

g++ …

有没有办法在类析构函数之前调用字段析构函数？

假设我有 2 个类Small和Big，并且Big包含一个Small作为其字段的实例，如下所示：

class Small
{
public:
    ~Small() {std::cout << "Small destructor" << std::endl;}
};

class Big
{
public:
    ~Big() {std::cout << "Big destructor" << std::endl;}

private:
    Small small;
};

int main()
{
    Big big;
}

当然，这在小析构函数之前调用大析构函数：

Big destructor
Small destructor

我需要在Small析构函数之前调用Big析构函数，因为它为Big析构函数做了一些必要的清理工作。

我可以：

1. small.~Small()显式调用析构函数。-> 然而，这Small两次调用析构函数：一次显式调用，一次在Big析构函数执行后。
2. 有Small*作为的领域，并呼吁delete small;在Big析构函数

我知道我可以在Small类中有一个函数来进行清理并在Big析构函数中调用它，但我想知道是否有办法反转析构函数的顺序。

有没有更好的方法来做到这一点？

这是我在这里发表的第一篇文章,但我要感谢社区,因为我已经无数次地找到解决问题的方法来到这里并在一个已经回答的问题中找到解决方案.

话虽如此,我想谈谈这一点.我在Code Gear的Delphi 2007 IDE中工作.我还是刚开始在德尔福工作的新手,准确地说还不到3个月,所以请记住这一点,因为我可能会遗漏一些基本的东西.

首先,我想就问题提供一些背景知识.我正在编写一个调度实用程序,用于在特定时间执行任务.对于每个可用任务,有2个与该任务相关联的相关delphi帧.第一帧用于编辑特定于该任务的详细信息,第二帧用于在任务运行时显示运行时信息.

保留正在运行的任务列表,并在该实用程序的滚动框中,显示运行时信息的相应帧列表.在任务开始和结束时创建和销毁这些运行时帧.这让我想到了我的问题.

我使用虚拟类管理器来保存每个任务的可用显示和编辑框架列表,并根据需要动态创建它们.在运行期间,一切都运行正常,当应用程序实际关闭时,我看到了问题.

该程序在关闭时会抛出EAccessViolation异常.当我尝试使用IDE跟踪问题时,我的代码中实际上并不存在与问题相对应的行或操作.因此,它必须是在后台执行的一些清理功能的一部分.

我已经将它缩小到动态创建虚拟类帧的代码,因为当我将代码注释掉时它会很好地关闭.因此,这让我相信我没有执行与使用此类类创建相关的操作.

var
  tmpCCI: TComponentClassInfExt;
  tmpS: String;
  tc: TComponent;
  bf: TBaseactionedit;
...
begin
...
tc := tmpCCI.fComponentClass.Create(nil);
if tc is TBaseactionedit then
begin
  bf := TBaseActionEdit(tc);
  bf.name := tmpCCI.fComponentClass.classname+IntToStr(nameCount);
  bf.Visible := False;
  bf.parent := pnlActionEdit;
  bf.Align := alClient;
  bf.Visible := True;
end;
...

这是我如何使用虚拟类管理器创建框架的摘录.当我们不再需要FreeAndNil时,我可以释放它们.我已尽最大努力确保在应用程序关闭之前我已正确释放任何实例,但显然我遗漏了一些东西.

那么有没有人有任何想法从这里调试这样的东西？

PS再一次我是新手,所以如果有什么我错过了,掩饰,或忘记添加,请告诉我.再次感谢您阅读我的帖子!

假设我们有一个base班级和一个班级derived.所以:

class base {
     protected:
          ~base(){
                //...
          }
     // ...
};

class derived : public base {
     // ...
};

现在说我们使用上面的类和智能指针类有这个代码:

SmartPointer<base> bptr(new derived());
delete bptr;

我知道它会derived通过调用析构函数来阻止对象的切片derived,但它如何知道呢？存储在智能指针中的引用不会是类型的引用base*吗？它是否遍历某种层次结构树,将该指针强制转换为derived*然后调用delete？还是有其他一些我不知道的事情？

该实现被认为是线程安全的,非侵入式的和引用计数.

是的,你看到的类类似于我正在测试的类.显然有一种方法可以使用THESE GIVEN课程.关于如何在上面的问题中提到的主要想法,但我不确定这样的实现如何工作.

在我的网络应用程序中，我经常需要重新实例化 Worker 对象，因为无法将新脚本传递给旧的现有对象。一段时间后，某些浏览器开始阻止创建新的 Worker 对象，因为已达到一个窗口的 Workers 限制。我尝试在创建新的工作对象之前删除已完成的工作对象，但显然我这样做的方式是错误的。这是一个简单的测试，在 Opera 中失败（限制为每个窗口 256 个工作线程）：

var worker;    
for(var i = 0; i < 300; i++) {
  for (var key in worker) worker[key] = null;
  delete worker.onmessage;
  delete worker.onerror;
  delete worker;
  worker = new Worker("script.js");
}

我的问题是如何完全删除工作对象，以便永远不会达到浏览器限制？谢谢你！

是否可以删除其类中的对象表单？

class A():
    def __init__(self):
        print("init")
        self.b="c"
    def __enter__(self):
        print("enter")
        return self
    def __exit__(self, type, value, traceback):
        print("exit")      

with A() as a:
    print(a.b)
print(a.b)

收益:

init
enter
c
exit
c

为什么a退出后我仍然可以访问该对象with？有没有办法自动删除对象__exit__？

我有一个名为Point如下的类：

public class Point {
    public int x;
    public int y;

    public Point(int X, int Y){
        x = X;
        y = Y;
    }

    public double Distance(Point p){
        return sqrt(((this.x - p.x) * (this.x - p.x)) + ((this.y - p.y) * (this.y - p.y)));
    }

    protected void finalize()
    {
        System.out.println( "One point has been destroyed.");
    } 
}

我有一个来自此类的对象，名称p如下：

Point p = new Point(50,50);

我想删除这个对象，我搜索了怎么做，我找到的唯一解决方案是：

p = null;

但是Point的finalize方法在我做了之后就没有用了。我能做什么？

我刚刚遇到了一些 C++ 容器实现。该类使用内部缓冲区来管理其对象。这是一个没有安全检查的简化版本：

template <typename E> class Container
{
public:
   Container() : buffer(new E[100]), size(0) {}
   ~Container() { delete [] buffer; }

   void Add() { buffer[size] = E(); size++; }
   void Remove() { size--; buffer[size].~E(); }

private:
   E* buffer;
   int size;
};

据我所知，如果/没有自定义，这将E冗余地构造/销毁对象。这看起来很危险。Container()~Container()newdelete

使用放置是否是防止危险的冗余构造函数/析构函数调用的最佳new方式Add()（除了将类绑定到功能齐全的池之外）？

使用 Placement 时new，new char[sizeof(E)*100]分配缓冲区的正确方法是吗？