Question

如何在Managed C ++中编写以下C＃代码

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

Clarificaton： 对于托管对象。

Answer 1

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

（1）使用自动/基于堆栈的对象模拟使用块：

{
  SqlConnection conn(connectionString);
}

当下一个封闭块结束时，这将调用“conn”对象的析构函数。无论这是封闭函数，还是手动添加以限制范围的块都无关紧要。

（2）明确地调用“Dispose”，即破坏对象：

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

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

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

Answer 2

在Managed 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!
    }
}

什么是与C＃using语句等效的托管C ++

5 个答案: