什么是托管 C++ 等效于 C# using 语句

Question

如何在托管 C++ 中编写以下 C# 代码

void Foo()
{
    using (SqlConnection con = new SqlConnection("connectionStringGoesHere"))
    {
         //do stuff
    }
}

澄清： 对于托管对象。

Answer 1

假设您的意思是 C++/CLI（不是旧的托管 C++），以下是您的选择：

(1) 使用自动/基于堆栈的对象模拟 using-Block：

{
  SqlConnection conn(connectionString);
}

这将在下一个封闭块结束时调用“conn”对象的析构函数。这是封闭函数，还是您手动添加以限制范围的块都没有关系。

(2) 显式调用“Dispose”，即销毁对象：

SqlConnection^ conn = nullptr;
try
{
  conn = gcnew SqlConnection(conntectionString);

}
finally
{
  if (conn != nullptr)
    delete conn;
}

第一个将是“使用”的直接替代。第二个是一个选项，通常您不需要这样做，除非您有选择地将引用传递给其他地方。

Answer 2

在托管 C++ 中，只需使用堆栈语义即可。

void Foo(){
   SqlConnection con("connectionStringGoesHere");
    //do stuff
}

当 con 超出范围时，会调用“析构函数”，即 Dispose()。

Answer 3

你可以用 auto_ptr 风格做一些类似的：

void foo()
{
    using( Foo, p, gcnew Foo() )
    {
        p->x = 100;
    }
}

以下内容：

template <typename T>
public ref class using_auto_ptr
{
public:
    using_auto_ptr(T ^p) : m_p(p),m_use(1) {}
    ~using_auto_ptr() { delete m_p; }
    T^ operator -> () { return m_p; }
    int m_use;
private:
    T ^ m_p;
};

#define using(CLASS,VAR,ALLOC) \
    for ( using_auto_ptr<CLASS> VAR(ALLOC); VAR.m_use; --VAR.m_use)

供参考：

public ref class Foo
{
public:
    Foo() : x(0) {}
    ~Foo()
    {
    }
    int x;
};

Answer 4

#include <iostream>

using namespace std;


class Disposable{
private:
    int disposed=0;
public:
    int notDisposed(){
        return !disposed;
    }

    void doDispose(){
        disposed = true;
        dispose();
    }

    virtual void dispose(){}

};



class Connection : public Disposable {

private:
    Connection *previous=nullptr;
public:
    static Connection *instance;

    Connection(){
        previous=instance;
        instance=this;
    }

    void dispose(){
        delete instance;
        instance = previous;
    }
};

Connection *Connection::instance=nullptr;


#define using(obj) for(Disposable *__tmpPtr=obj;__tmpPtr->notDisposed();__tmpPtr->doDispose())

int Execute(const char* query){
    if(Connection::instance == nullptr){
        cout << "------- No Connection -------" << endl;
        cout << query << endl;
        cout << "------------------------------" << endl;
        cout << endl;

        return -1;//throw some Exception
    }

    cout << "------ Execution Result ------" << endl;
    cout << query << endl;
    cout << "------------------------------" << endl;
    cout << endl;

    return 0;
}

int main(int argc, const char * argv[]) {

    using(new Connection())
    {
        Execute("SELECT King FROM goats");//out of the scope
    }

    Execute("SELECT * FROM goats");//in the scope

}

Answer 5

如果您担心限制变量的生命周期而不是自动处置，您可以随时将其放入自己的范围：

void Foo()
{
    {
        SqlConnection con = new SqlConnection("connectionStringGoesHere");
        // do stuff
        // delete it before end of scope of course!
    }
}