Implementando el equivalente en C++ de C# usando la declaración

Question

Estoy buscando una solución elegante para implementar el equivalente de la declaración que usa C# en C++. Idealmente, la sintaxis resultante debería ser simple de usar y leer.

C# Usando datos de los estados están aquí - http://msdn.microsoft.com/en-us/library/yh598w02(v=vs.80).aspx

No estoy seguro de si la solución sería el uso de punteros de función con los destructores de las clases, algún tipo de programación de plantilla inteligente o incluso la programación plantilla de meta. Básicamente, no sé por dónde empezar con esto ...

Answer 1

No necesita implementar esto en C++ porque el patrón estándar de RAII ya hace lo que necesita.

{ 
    ofstream myfile; 
    myfile.open("hello.txt"); 
    myfile << "Hello\n"; 
} 

Cuando termina el ámbito de bloque, myfile se destruye que cierra el archivo y libera todos los recursos asociados con el objeto.

La razón por la cual la declaración using existe en C# es para proporcionar algo de azúcar sintáctico alrededor de try/finally y IDisposable. Simplemente no es necesario en C++ porque los dos idiomas son diferentes y el problema se resuelve de manera diferente en cada idioma.

Answer 2

Eche un vistazo al uso de std :: auto_ptr <> para manejar la limpieza de las instancias asignadas y asignadas a un puntero dentro de un alcance particular; de lo contrario, cualquier variable declarada dentro de un alcance específico simplemente será destruida cuando salir de dicho alcance.

{ 
    SomeClass A; 
    A.doSomething(); 
} // The destructor for A gets called after exiting this scope here 

{ 
    SomeClass* pA = new SomeClass(); 
    std::auto_ptr<SomeClass> pAutoA(pA); 
    pAutoA->doSomething(); 
} // The destructor for A also gets called here, but only because we 
    // declared a std::auto_ptr<> and assigned A to it within the scope. 

Ver http://en.wikipedia.org/wiki/Auto_ptr un poco más de información sobre std :: auto_ptr <>

Answer 3

me gustaría recomendar la lectura de los siguientes enlaces:

1. C++ RAII compared with Java Dispose pattern
2. Constructor Exceptions in C++, C#, and Java
3. More C++ Idioms/Resource Acquisition Is Initialization
4. Resource Acquisition Is Initialization (RAII)

Answer 4

Un patrón RAII más detallado que se asemeja using C# 's se puede lograr con un simple macro.

#define Using(what, body) { what; body; } 

Using(int a=9, 
{ 
    a++; 
}) 

a++; // compile error, a has gone out of scope here 

Nota debemos usar mayúscula "Uso" para evitar una colisión con C++ 's construido en el 'uso' declaración que, obviamente, tiene un significado diferente.

Answer 5

vistazo a lo siguiente:

#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 

}