Utilisation de RAII avec un pointeur de caractères

Question

Je vois beaucoup de classes d'exemple RAII entourant les handles de fichiers.

J'ai essayé d'adapter ces exemples sans chance à un pointeur de caractère.

Une bibliothèque que j'utilise possède des fonctions qui prennent l'adresse d'un pointeur de caractère (déclaré comme get_me_a_string (char ** x)). Ces fonctions allouent de la mémoire pour ce pointeur de caractères et laissent à l'utilisateur final de la bibliothèque le soin de le nettoyer dans son propre code.

Donc, j'ai le code qui ressemble à ceci ...

char* a = NULL; 
char* b = NULL; 
char* c = NULL; 

get_me_a_string(&a); 
if(a == NULL){ 
    return; 
} 


get_me_a_beer(&b); 
if(b == NULL){ 
    if(a != NULL){ 
     free(a); 
    } 
    return; 
} 


get_me_something(&c); 
if(c == NULL){ 
    if(a != NULL){ 
     free(a); 
    } 
    if(b != NULL){ 
     free(b); 
    } 
    return; 
} 

if(a != NULL){ 
    free(a); 
} 
if(b != NULL){ 
    free(b); 
} 
if(a != NULL){ 
    free(b); 
} 

On dirait que RAII est la réponse pour ce gâchis que j'ai ci-dessus. Quelqu'un pourrait-il fournir une simple classe C++ qui enveloppe un char * plutôt qu'un fichier *?

Merci

Answer 1

Une implémentation très basique (que vous devriez faire noncopyable etc).

struct CharWrapper { 
    char* str; 
    CharWrapper(): str() {} // Initialize NULL 
    ~CharWrapper() { free(str); } 
    // Conversions to be usable with C functions 
    operator char**() { return &str; } 
    operator char*() { return str; } 
}; 

Ceci est techniquement pas RAII, comme une initialisation se produit au plus tard au constructeur, mais il prendra soin de nettoyage.

Answer 2

Il existe déjà quelque chose dans la bibliothèque standard: il s'appelle std::string.

Edit: À la lumière de nouvelles informations:

Il allouer de la mémoire et le remplir vers le haut. Je pourrais copier le contenu dans un nouvel objet std :: string mais je devrais encore libérer la mémoire allouée par la fonction.

Ceci est une mauvaise conception de la part de l'implémenteur - le module qui alloue devrait être responsable de la désallocation. Ok, maintenant que je l'ai sorti de mon système: vous pouvez utiliser un boost::shared_ptr pour libérer.

template<typename T> 
struct free_functor 
{ 
    void operator() (T* ptr) 
    { 
     free(ptr); 
     ptr=NULL;    
    } 
}; 
shared_ptr<X> px(&x, free_functor()); 

Answer 3

je pense auto_ptr est ce que vous voulez

ou stimuler shared_ptr si la sémantique de auto_ptr ne travaillent pas pour vous

Answer 4

soit utiliser std::string ordinaire ou boost::scoped_array pour les tableaux locaux ou boost::shared_array pour les chaînes partagées (celui-ci vous permet de fournir Deleter personnalisée pour appeler free())

Answer 5

vous pouvez essayer quelque chose comme ceci:.

template <typename T> 
class AutoDeleteArray 
{ 
public: 
    explicit AutoDeleteArray(const T* ptr) 
     : ptr_(ptr) 
    {} 
    ~AutoDeleteArray() 
    { 
     delete [] ptr_; 
     // if needed use free instead 
     // free(ptr_); 
    } 

private: 
    T *ptr_; 
}; 

// and then you can use it like: 
{ 
    char* a = NULL; 

    get_me_a_string(&a); 
    if(a == NULL) 
     return; 

    AutoDeleteArray<char> auto_delete_a(a); 
} 

Ce n'est pas la solution la plus fiable, mais pourrait suffire à cette fin. PS: Je me demandais std::tr1::shared_ptr avec le travail de deleter personnalisé aussi bien?

Answer 6

Merci à tous pour vos réponses.

Malheureusement, je ne peux pas utiliser boost, ou d'autres bibliothèques sur ce projet ... donc toutes ces suggestions sont inutiles pour moi.

J'ai regardé des choses comme la gestion des exceptions dans C comme ici ... http://www.halfbakery.com/idea/C_20exception_20handling_20macros

Et puis je regardais pourquoi C++ n'a pas finalement comme Java et suis tombé sur ce genre de choses RAII.

Je ne suis toujours pas sûr si je vais aller dans le sens de destructor et rendre le code C++ uniquement, ou le bâton avec de C exception macro (qui utilisent le goto redoutée :)

Tronic a suggéré quelque chose comme ce qui suit. Avec RAII, ou les destructeurs en général, sont-ils censés être à l'épreuve des coupures? Je ne devine pas. La seule chose que je n'aime pas est le fait que je dois maintenant utiliser un cast (char *) dans mes instructions printf.

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

struct CharWrapper { 
    char* str; 
    CharWrapper(): str() {} // Initialize NULL 
    ~CharWrapper() { 
     printf("%d auto-freed\n", str); 
     free(str); 
    } 
    // Conversions to be usable with C functions 
    operator char*() { return str; } 
    operator char**() { return &str; } 
}; 

// a crappy library function that relies 
// on the caller to free the memory 
int get_a_str(char **x){ 
    *x = (char*)malloc(80 * sizeof(char)); 
    strcpy(*x, "Hello there!"); 
    printf("%d allocated\n", *x); 
    return 0; 
} 


int main(int argc, char *argv[]){ 
    CharWrapper cw; 
    get_a_str(cw); 
    if(argc > 1 && strcmp(argv[1], "segfault") == 0){ 
     // lets segfault 
     int *bad_ptr = NULL; 
     bad_ptr[8675309] = 8675309; 
    } 
    printf("the string is : '%s'\n", (char*)cw); 
    return 0; 
} 

Answer 7

Une solution alternative serait quelque chose comme ça, ce qui est de savoir comment j'écrire ce code dans C:

char* a = NULL; 
char* b = NULL; 
char* c = NULL; 

get_me_a_string(&a); 
if (!a) { 
    goto cleanup; 
} 

get_me_a_beer(&b); 
if (!b) { 
    goto cleanup; 
} 

get_me_something(&c); 
if (!c) { 
    goto cleanup; 
} 

/* ... */ 

cleanup: 
/* free-ing a NULL pointer will not cause any issues 
* (see C89-4.10.3.2 or C99-7.20.3.2) 
* but you can include those checks here as well 
* if you are so inclined */ 
free(a); 
free(b); 
free(c); 

Answer 8

Puisque vous dites que vous ne pouvez pas utiliser boost, il est peu Difficile d'écrire un pointeur intelligent très simple qui ne partage pas ou ne transfère pas de ressources.

Voici quelque chose de basique. Vous pouvez spécifier un foncteur de deleter en tant que paramètre de modèle. Je ne suis pas particulièrement friand des opérateurs de conversion, donc utilisez plutôt la méthode get(). Ajoutez d'autres méthodes comme release() et reset() à volonté.

#include <cstdio> 
#include <cstring> 
#include <cstdlib> 

struct Free_er 
{ 
    void operator()(char* p) const { free(p); } 
}; 

template <class T, class Deleter> 
class UniquePointer 
{ 
    T* ptr; 
    UniquePointer(const UniquePointer&); 
    UniquePointer& operator=(const UniquePointer&); 
public: 
    explicit UniquePointer(T* p = 0): ptr(p) {} 
    ~UniquePointer() { Deleter()(ptr); } 
    T* get() const { return ptr; } 
    T** address() { return &ptr; } //it is risky to give out this, but oh well... 
}; 

void stupid_fun(char** s) 
{ 
    *s = static_cast<char*>(std::malloc(100)); 
} 

int main() 
{ 
    UniquePointer<char, Free_er> my_string; 
    stupid_fun(my_string.address()); 
    std::strcpy(my_string.get(), "Hello world"); 
    std::puts(my_string.get()); 
}