Qual è il C ++ gestito equivalente all'istruzione using C #

Question

Come si potrebbe codificare il seguente codice C # in Managed C ++

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

Clarificaton: Per oggetti gestiti.

Answer 1

Supponendo che intendi C ++ / CLI (non il vecchio C ++ gestito), le seguenti sono le tue opzioni:

(1) Imita un blocco usando con oggetti automatici / basati su stack:

{
  SqlConnection conn(connectionString);
}

Questo chiamerà il Distruttore di " conn " Oggetto quando termina il blocco di chiusura successivo. Non importa se questa è la funzione che racchiude o un blocco che aggiungi manualmente per limitare l'ambito.

(2) Chiama esplicitamente " Dispose " ;, cioè distruggi l'oggetto:

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

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

Il primo sarebbe la sostituzione diretta per " usando " ;. La seconda è un'opzione, in genere non dovrai farlo a meno che non passi facoltativamente il riferimento da qualche altra parte.

Answer 2

A quello in Managed C ++ basta usare la semantica dello stack.

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

Quando con esce dall'ambito di applicazione, viene chiamato " Destructor " ;, ovvero Dispose ().

Answer 3

Puoi fare qualcosa simile in uno stile auto_ptr:

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

con il seguente:

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)

Per riferimento:

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

Se sei preoccupato di limitare la durata della variabile piuttosto che lo smaltimento automatico, puoi sempre metterlo nel suo ambito:

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