标签: object-lifetime

而不是使用这样的界面:

public interface IStartable
{
    void Start();
    void Stop();
}

我通常只是使对象的构造函数运行Start()代码,并实现IDisposable,以便dispose方法运行Stop()代码.

这只是风格问题吗？或者我没有像IStartable这样的东西错过了一些重要的东西？我所看到的只是额外的复杂性,因为你必须保持它的启动/停止状态.

使用启动/停止与使用ctor/dispose的优缺点是什么,特别是在IoC/DI容器的上下文中？

编辑:很好的答案,你已经说服我使用一个可启动对象的界面.我无法确定谁的答案是最好的,所以我会接受24小时后得票最多的人.

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

const char* funA()
{
    return "aa"; // where does system to store this temporary variable?
}

// this is not an valid function
const char* funB()
{
    string str("bb");

    return str.c_str();
}


int _tmain(int argc, _TCHAR* argv[])
{
    cout << funA() << endl;
    cout << funB() << endl; // invalid
    return 0;
}

问题>我们不应该返回指向函数内局部变量的指针或引用.因此返回变量"aa"不是funA函数内的局部变量.那这是什么？

谢谢

这是一个相当不错的观点,我希望答案是"开始时并不是一个好主意" - 也就是说,如果某人有点放纵,它有一个我感兴趣的点.

型号代码:

public partial class MyEntities : ObjectContext
{
    // the idea is if the object is in a using block, this always gets called?
    protected override void Dispose(bool disposing)
    {
        this.SaveChanges();
        base.Dispose(disposing);
    }
}

客户代码:

using(var model = new MyEntities())
{
   // do something

   // no worry about calling model.SaveChanges()
}

我不确定的问题是:

1. 处置正确的地方是因为我出于某种原因想到"终结" - 我总是对C#破坏感到困惑.

2. 在客户端代码中抛出异常的情况下,通常会跳过SaveChanges并且这很好,但是如果我认为这是有效的,那么它总是会调用它.我应该尝试空捕获吗？

   public partial class MyEntities : ObjectContext
   {
       protected override void Dispose(bool disposing)
       {
           try
           {
              this.SaveChanges();
           }
           catch {}
           base.Dispose(disposing);
       } …

   Run Code Online (Sandbox Code Playgroud)

当我从C#转换到C++时,我得到了很多建议,尽可能使用值语义.几乎可以肯定的是,如果我在任何地方发布带有指针的问题,并建议它应该是一个值.我开始看到了光,我在代码中找到了很多地方,我可以用堆栈分配的变量(通常是引用)替换动态分配和指针.所以我认为我掌握了使用堆栈分配的对象,并且当调用者中的对象生命周期比被调用者更长时,将它们作为引用传递给其他函数.

但是,当被调用者获得所有权时,我有一个关于按值传递对象的问题.请看以下示例:

class Zoo
{
  void AddAnimal(Animal animal);
  std::list<Animal> animals_;
}

通常从灵活性和单元测试的角度来看,我希望Animal成为一个接口(C++中的抽象类),这样我就可以轻松地发送任意动物并通过模拟实现来模拟它.

在指针实现中,客户端代码将调用它:

Animal animal = new Lion("Bob");
myZoo.AddAnimal(animal);

这里的客户端代码并不真正需要动物对象.它只是暂时构建它以传递给方法.所以在这种情况下,没有共享语义.所以它似乎是价值语义的一个好例子.但是,我的理解是你不能使用Animal作为值传递的参数,因为它是一个抽象类.

我的大多数不采用原始类型的成员函数都采用抽象类参数.那么处理这个问题的C++方法是什么？(那你是如何使用值语义编写C++接口的呢？)

传递方法参数的Java Object的生命是什么？

例如,我有一个对象Test

class Test{

    public string testType(){
       .....
    }
}

我有两个A和B类

class classA{

   classB b = new classB();

   void nextQuestion{
      b.start(new Test());
   }
}




class classB{
   void start(Test test){
      doSomething(test.testType());
   }
}

那么现在Test对象的生命是什么？它只是直到start方法的结尾,或者它会一直存在直到classB结束,或者它活着直到classA结束或者是其他东西.

以下代码在C++中是否合法？

template<typename T>
class Foo {
public:
    Foo(T& v) : v_(v) {}

private:
    T& v_;
};

int a = 10;
Foo<int> f(a);

void Bar(int& a) {
    new (&f)Foo<int>(a);
}

引用不应该被绑定两次,对吧？

我有一个使用 C++ Builder 10.1 Berlin 构建的跨平台 C++ 应用程序，并且在理解对象的生命周期处理时遇到问题，在这种情况下是在类之外声明的字符串。我创建了一个新的表单应用程序并添加了一些代码。cpp 文件如下所示：

#include
#pragma hdrstop
#include "FmrMain.h"
#pragma package(smart_init)
#pragma resource "*.fmx"
TForm1 *Form1;

const String Hello = "Hello";

__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
   ShowMessage(Hello);
}

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
   ShowMessage(Hello);
}

我使用 CLANG 增强型 C++11 编译器 bcc32c 编译它，运行应用程序并再次关闭表单。当 TForm1::FormDestroy 被调用时，Hello 已经被销毁了。当我使用经典编译器 bcc32 为 win32 编译代码时，字符串在 FormDestroy 之后被销毁。

有人可以解释这一点或提供一些有关我必须寻找的主题的信息吗？为什么基于 CLANG 的编译器在这里表现不同？

编辑

当我使用自定义类而不是字符串时，调试更容易。

class Foo {
public:
   Foo(){};
  ~Foo(){}
};
Foo A;

//--------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------------- …

编译器不会为以下代码抛出任何警告或错误.const限定符的含义是否被滥用？显然,我不能在同一循环迭代中重新分配它,但它确实似乎在每次迭代后重新分配它.

示例代码:

for(int i = 0; i < 10; ++i)
{
  const int constant = i;
}

学习Rails,控制器实例化的点对我来说是不清楚的,而模型实例化的点在某种程度上是可识别的,例如,当用户在from中输入数据并单击提交按钮时是一种触发器这导致了对象模型的创建.

完成了一些研究,我在脑海中可视化,当通过浏览器发送HTTP请求时,到控制器的路由成为从控制器类实例化某个控制器对象的触发器.

这有点正确吗？

在我的构造函数中，如果其中包含任何代码，我必须销毁所有剩余资源。我想避免编写重复的代码，所以我只在catch块中调用析构函数即可释放已创建的任何资源。这样安全吗？

我知道如果构造函数抛出异常，则不会调用析构函数，因此我尝试在msvc中编译一些代码，但似乎没有什么错，但是我不确定这是否很幸运。

Object::Object(){
    try{
        // Initialize multiple resources here.
    }catch(...){
        this->~Object(); // Is this safe?
        throw;
    }
}

Object::~Object(){
    // release multiple resources, if initialized.
}