标签: object-lifetime

.vbs中的对象以什么顺序销毁？

也就是说,给定这些全局变量:

Set x = New Xxx
Set y = New Yyy

我对以下任何一个问题的答案感兴趣.

1. 对于.VBS中实现的类的实例,将以什么顺序Class_Terminate调用？粗略的戳戳建议创造的顺序(而不是逆序!),但这有保证吗？

   编辑:我知道Class_Terminate将在释放对象的最后一次引用时调用.我的意思是:x和y的发布顺序是什么,是否有保证？为简单起见,假设x和y是对其各自对象的唯一引用.

2. 对象的类型是否重要？例如,如果我在.VBS中实现的类与其他COM对象混合在一起,例如Scripting.FileSystemObject.

   编辑:我知道COM库可能会设置自己的内部循环引用,脚本主机引擎一无所知; 我有兴趣探索可能影响第一个问题答案的内容.

3. 上述不同的答案如果x和y是Sub或Function的本地而不是全局？
4. 是否取决于退出是正常的,例外还是通过WScript.Quit？(在后一种情况下,似乎Class_Terminate在退出之前仍然会调用任何未完成的对象,但这些可能会导致报告错误).
5. 什么时候WScript对象被破坏？
6. 脚本是否重要？(wscript.exe vs cscript.exe与调用Web主机引擎无关)
7. JScript的对象销毁模型与VBScript的不同吗？

我可以凭经验找到其中一些问题的答案,但我对它们中的任何一个是否得到保证 /记录感兴趣.

即使你只知道一些答案 - 或进一步的相关问题,请发帖.

std::string getMyString() { return <make a string>; }

...

HANDLE something = OpenSomething(getMyString().c_str(), ...);

我已经读过C++中的临时保证生命周期,并且我相信临时字符串将一直存在,直到评估了赋值,即足够长以使其按预期工作.

有一次遇到与std::string生命有关的错误(不记得是什么)我宁愿仔细检查......

• 我将计划使用Redis(ServiceStack)作为Web应用程序的整个数据库.
• 我可以在7.4秒内插入76000条记录.
• 但是使用单一连接(RedisClient对象生命周期是应用程序),
• 我使用Set泛型方法而非Store(巨大的性能差异)

我曾使用Per-Request对象生命周期来实现Entity Framework ObjectContext.

那么Redis(ServiceStack)的Web应用程序(Asp.Net MVC)中对象生命周期的最佳策略是什么？

或者Redis不是100个Sql Server Tables的成熟项目(各种各样的相互关联)

我完全糊涂了......我想将实体存储在DB4O中(我恐怕'DB4o也是嵌入式Java Db'的口号),Redis中的关系？!

并支持在EF4中包含概念.

我的整个项目将拥有1.000.000个实体,100,000个关系!(我有3年实体框架1-4经验)

我创建了一个继承自MarshalByRefObject和的对象ISponsor。在我的实现中，ISponsor我只返回一个时间跨度来指示我希望对象更新多长时间。

当我调用InitializeLifetimeService()以获取ILease要传递到我的ISponsor对象中的引用时，它似乎从未在我见过的示例中使用过。

ISponsor似乎只是在没有实际使用ILease参考的情况下返回一个 TimeSpan 。但我敢肯定，由于涉及远程处理，这里还有更多事情要做。

如何工作ISponsor和ILease工作，特别是在对象生命周期更新方面？

请考虑以下代码:

#include <iostream>

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

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

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

  void operator<<(const B &) {}
};

C f(const A &a = A()) {
  return C();
}

int main() {
  f(A()) << B();
}

使用GCC进行编译并运行会提供以下输出:

~C
~A
~B

是否保证在与其他编译器一起编译时,将按此顺序调用类型A,B和C的临时对象的析构函数？一般来说,如果有的话,析构函数调用的顺序是什么？

我在工作中遇到了一些代码,如下所示:

var $divs = $('div');
var $jq   = $([1]);

$divs.each(function () {
    $jq.context = $jq[0] = this;
    // ... do stuff ...
});

我perf'd以上,而且似乎比拥有更快$this = $(this);的函数的顶部.在函数内部,$jq变量具有标准的各种典型的jQuery方法,称为off(.hasClass(), .data(), .find(), ...),代码按预期工作.

我想知道这里的权衡是什么; 也就是你每次不构建一个新对象会失去什么？我只是失去了"历史"(即.pushStack(), .end(), .andSelf(), ...)？我应该一直这样做吗？

另外,这是一个命名模式吗？我不能为我的生活弄清楚如何在谷歌上研究这个.

std :: aligned_storage :: type是POD类型.POD类型可以memcpy.但是,如果将新的非平凡可复制类型放置到std :: aligned_storage会发生什么？它能记得那个std :: aligned_storage吗？

非平凡可复制类型(非POD类型)不能memcpy,行为未定义.如果std :: aligned_storage memcpy是非平凡可复制的类型,它是否也是未定义的行为？

#include <new>
#include <type_traits>
#include <cstring>
#include <iostream>

struct y { int a; } ;

// non-trivially-copyable
struct t
{
    y a;
    int* p;
    t(){ p = new int{ 300 }; }
    t( t const& ){ a.a += 100; }
    ~t(){ delete p; }
};

int main()
{   // Block 1
    { 
        t a; a.a.a = 100;
        t b; b.a.a = 200;
        // std::memcpy(&b,&a,sizeof(t));  // abort...non-trivially-copyable
    } …

C++标准草案N4296说

[class.temporary/5]第二个上下文是引用绑定到临时的.引用绑定的临时值或作为绑定引用的子对象的完整对象的临时值在引用的生命周期内持续存在,除了...

所以我想知道如果两个或多个引用绑定到临时引发会发生什么.它在标准中是否具体？以下代码可能是一个示例:

#include <iostream> //std::cout
#include <string>   //std::string
const std::string &f() {
    const std::string &s = "hello";
    static const std::string &ss = s;
    return ss;
}
int main() {
    const std::string &rcs = f();
    std::cout << rcs; //empty output
                      //the lifetime of the temporary is the same as that of s
    return 0;
}

如果我们改变边界顺序,情况就不同了.

#include <iostream> //std::cout
#include <string>   //std::string
const std::string &f() {
    static const std::string &ss = "hello";
    const std::string &s = ss;
    return …

我有一个ServiceProvider类,其中包含几个指向不同服务的指针,如:

class ServiceProvider()
{
    Service3* GetService3();

public:
    void Process(Object* o);
    void Shrink();

private:
    TAutoSpawningPtr<Service1> service1;
    TAutoSpawningPtr<Service2> service2;

    Service3* service3;
}

注意,这TAutoSpawningPtr是一个理论上的智能指针？lass我正在寻找,而service3被声明为一个普通的指针,以明确显示我需要的行为.身体Process():

void ServiceProvider::Process(Object* o)
{
    service1->Process(o);
    service2->Process(o);
    GetService3()->Process(o);
}

身体GetService3():

void ServiceProvider::GetService3()
{
    if(!service3)
    {
       service3 = new Service3();
    }

    return service3;
}

正如您所看到的,Service3正在创建一个懒惰的实例,并且在需要之前它不存在.

Shrink()定期调用方法以删除所有内部服务.像这样:

void ServiceProvider::Shrink()
{
    service1.Release(); // delete its internal Service1 pointer if it exists.
    service2.Release(); // delete its internal Service2 pointer if it exists.

    if …

请考虑以下示例.当bar被构造,它给它的基本类型(foo)构造的地址my_member.y,其中my_member是还没有被初始化的数据成员.

struct foo {
    foo(int * p_x) : x(p_x) {}
    int * x;
};

struct member {
    member(int p_y) : y(p_y) {}
    int y;
};

struct bar : foo
{
    bar() : foo(&my_member.y), my_member(42) {}
    member my_member;
};

#include <iostream>

int main()
{
    bar my_bar;
    std::cout << *my_bar.x;
}

这个定义得很好吗？获取未初始化对象的数据成员的地址是否合法？我发现了一个关于传递对未初始化对象的引用的问题,但它并不完全相同.在这种情况下,我在未初始化的对象上使用成员访问运算符 ..

这是真的,一个对象的数据成员的地址不应该被初始化改变,但这并不一定能使服用很好地定义了地址.此外,成员访问运营商的ccpreference.com页面有这样的说法:

即使没有必要,也会评估两个运算符的第一个操作数(例如,当第二个操作数命名为静态成员时).

我理解这意味着在&my_member.y my_member将被评估的情况下,我认为这很好(int x; x;似乎很好),但我找不到文件来支持它.