标签: object-lifetime

是否有建议的模式来关闭/关闭使用Guice创建的对象？

我的目标是:

1. 准备一个Guice模块
2. 创建一个注射器
3. 通过代码使用注入器来获取对象(injector.getInstance(Foo.class))
4. ...
5. 关闭所述对象持有的所有资源(文件句柄,TCP连接等).我希望这是一个确定性的步骤(而不是"GC运行的某一天").

我需要一种方法来跟踪各种类的实例,而不需要那些知道它们被跟踪的类.基本上,我有一个类工厂,它创建实例并将它们交给另一个线程.一旦该线程完成并卸载实例,我需要得到通知,这样我就可以引用计数并在所有实例都消失后退出我的类工厂.

挑战在于我无法修改我将加载的任何类,因为我无法控制它们的源代码.

跟踪我创建的实例很简单,我可以在创建它们时将它们放在某种集合中.跟踪他们的破坏导致我的问题.如果我可以修改源代码,我会向每个类添加一个事件,当我创建一个实例时,我会挂钩事件并将其用作我的通知.但我不能这样做.

所以,问题是:是否有一种偷偷摸摸的方式来监视对象实例并检测它何时被销毁？

在这个问题的用户愉快塔尔引用C++ 03标准的部分12.2.5:临时结合到在一个构造的构造函数初始化程序(12.6.2)的参考构件持续直到构造退出.

这怎么可能有用呢？我的意思是一旦构造函数退出临时被破坏,但引用仍然绑定 - 现在已经被破坏的对象.

如果在外部对象的整个生命周期中仍然存在悬空引用,那么如何仔细指定临时生命周期又有什么意义呢？在哪种情况下这种行为有用吗？

这可能是不可能的,但我想知道是否有可能暂时不会超过其原始表达.我有一个指向父对象的对象链,以及一个将创建子对象的成员函数,这里有一个简化的例子

class person{
    string name;
    person * mommy;
public:
    person(const string & nam, person * m = 0) : name(nam), mommy(m) {}
    person baby(const string & nam){
        return person(nam, this);
    }
    void talk() const{
        if (mommy) mommy->talk();
        cout << name << endl;
    }
};

int main(){
    person("Ann").baby("Susan").baby("Wendy").talk();     // fine

    const person & babygirl = person("Julie").baby("Laura"); // not fine

    babygirl.talk();    // segfault
    return 0;
}

我想要使​​用的方法person是将它传递给一个函数,如下所示:

void use(const person & p) {
    p.talk();
}
use(person("Anna").baby("Lisa"));

很好.

只要没有一个临时表现在原始表达式之后,这就可以正常工作,但是如果我把一个最后的临时工具绑定到一个const引用,那么它的父母就无法生存,我得到一个段错误.我可以隐藏person复制构造函数和赋值运算符,但有什么方法可以防止这种错误发生？如果可能的话,我想避免动态分配.

我想知道关于下面这段代码的标准是什么.可以string临时对象的析构函数调用之前执行printPointer？

ps VS2010编译器不会抱怨此代码并且工作正常.

void printPointer(const string* pointer)
{
    cout << *pointer << endl;
}

const string* func(const string& s1)
{
    return &s1;
}

int main()
{
    printPointer(func("Hello, World!!!"));
}

考虑以下示例程序:

#include <iostream>
using namespace std;
struct t
{
    ~t() {cout << "destroyed\n"; }
};
int main()
{
    cout << "test\n";
    t(), cout << "doing stuff\n";
    cout << "end\n";
}

我从GCC 4.9.2获得的输出是:

test 
doing stuff 
destroyed 
end

cpp.sh链接:http://cpp.sh/3cvm

但是根据关于逗号运算符的cppreference:

在逗号表达式E1,E2中,评估表达式E1,丢弃其结果,并且在评估表达式E2开始之前完成其副作用

我希望~t()以前能打电话给我cout << "doing stuff"

这是标准行为吗？如果是这样,标准中的定义在哪里？

我正在开发一些课程,并提出了这个问题.考虑我有以下课程:

struct A
{
    int *p;
    A() 
    {
        p = new int(1); 
        cout << "ctor A" << endl; 
    }
    A(const A& o) 
    { 
        cout << "copy A" << endl;
        p = new int(*(o.p));
    }
    A(A&& o) 
    {
        cout << "move A" << endl;
        p = std::move(o.p);
        o.p = NULL;
    }
    A& operator=(const A& other)
    {       
        if (p != NULL)
        {
            delete p;
        }
        p = new int(*other.p);
        cout << "copy= A" << endl;
        return *this;
    }
    A& operator=(A&& other)
    { …

我知道可以安全地将简单的可复制对象复制malloc到适当的存储位置¹,并且目标对象将具有与源相同的值.

这也可能realloc吗？也就是说,如果realloc某个存储包含某些类型的对象T,并realloc决定移动并复制该块,新分配的存储中的对象是否完整并且已经开始其生命周期,并且旧存储中的对象的生命周期将是安全的结束了？

¹在提出这个问题时,我曾假设"适当的存储位置"包括适当对齐和大小的未初始化存储,但正如MM的答案所述,这并不是标准所支持的.这会让人realloc怀疑,因为它总是复制到未初始化的存储中.

在一些主对象的析构函数中在堆栈上创建一个worker-object并将master-object的this指针传递给helper-object 是合法的C++ 吗？然后,辅助对象还将调用主对象的成员函数或访问成员变量.

换句话说,是以下合法的C++？

struct MasterClass
{
  MasterClass (int data);

  ~MasterClass ();

  int data;
};

struct WorkerClass
{
  WorkerClass (MasterClass *m) : m (m) { }

  void do_some_work () { m->data = 42; }

  MasterClass *m;
};

MasterClass::MasterClass (int data)
: data (data)
{ }

MasterClass::~MasterClass ()
{
  WorkerClass w (this);

  w.do_some_work ();
}

int main ()
{
  MasterClass m (7);
}

我知道,一旦析构函数开始执行,master-object的生命周期就会结束.但我认为在任何对象的析构函数中调用非虚拟成员函数是合法的,这些函数使用隐式this参数/参数.

请考虑这个简化的c++14程序：

#include <iostream>

struct A
{
    A() { std::cout << "A() "; }
    ~A() { std::cout << "~A() "; }
};

int main()
{
    auto l = std::initializer_list<A>{A()};
    std::cout << ". ";
}

https://gcc.godbolt.org/z/1GWvGfxne

GCC在这里打印

A() . ~A()

意思std::initializer_list是在范围结束时被破坏。

叮当印：

A() ~A() . 

std::initializer_list在它建造的那条线上销毁。

两个编译器都在这里正确运行还是其中之一是错误的？