4

我看到很多围绕文件句柄的 RAII 示例类。

我试图将这些示例改编为字符指针，但没有运气。

我正在使用的库具有获取字符指针地址的函数（声明为 get_me_a_string(char **x)）。这些函数为该字符指针分配内存，并将其留给库的最终用户在他们自己的代码中清理它。

所以，我有看起来像这样的代码......

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);
}

听起来 RAII 是我上面提到的这个烂摊子的答案。有人可以提供一个简单的 C++ 类来包装 char* 而不是 FILE* 吗？

谢谢

4

8 回答 8

5

标准库中已经有一些可用的东西：它被称为std::string.

编辑：根据新信息：

它将分配内存并将其填满。我可以将内容复制到一个新的 std::string 对象中，但我仍然必须释放该函数分配的内存。

这对实现者来说是糟糕的设计——分配的模块应该负责解除分配。

好的，现在我已经从我的系统中得到了这个：你可以使用 aboost::shared_ptr来释放。

template<typename T>
struct free_functor
{
    void operator() (T* ptr)
    {
        free(ptr);
        ptr=NULL;            
    }
};
shared_ptr<X> px(&x, free_functor());
于 2010-02-02T19:34:53.820 回答
2

一个非常基本的实现（你应该使不可复制等）。

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; }
};

这在技术上不是 RAII，因为正确的初始化发生在构造函数之后，但它会负责清理。

于 2010-02-02T19:34:29.017 回答
1

你可以尝试这样的事情：

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);
}

这不是最可靠的解决方案，但足以达到目的。

PS：我想知道std::tr1::shared_ptr自定义删除器也可以工作吗？

于 2010-02-02T19:46:47.330 回答
0

谢谢大家的回答。

不幸的是，我不能在这个项目上使用 boost 或其他库......所以所有这些建议对我来说都是无用的。

我已经看过像这里这样的C语言异常处理...... http://www.halfbakery.com/idea/C_20exception_20handling_20macros

然后我研究了为什么 C++ 没有像 Java 那样的 finally 并遇到了这个 RAII 的东西。

我仍然不确定我是否会采用析构函数的方式并仅使用 C++ 代码，还是坚持使用 C 异常宏（使用可怕的 goto :)

Tronic 建议如下。使用 RAII 或一般的析构函数，它们应该是段错误证明吗？我猜不是。

我唯一不喜欢的是我现在必须在我的 printf 语句中使用强制转换 (char*)。

#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;
}
于 2010-02-02T20:29:20.103 回答
0

另一种解决方案是这样的，这就是我用 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);
于 2010-02-02T20:56:04.613 回答
0

既然你说你不能使用 boost，那么编写一个不共享或传输资源的非常简单的智能指针并不难。

这是一些基本的东西。您可以将删除器函子指定为模板参数。我不是特别喜欢转换运算符，所以改用 get() 方法。

随意添加其他方法，如 release() 和 reset()。

#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());
}
于 2010-02-02T21:30:59.887 回答
0

我认为 auto_ptr 是你想要的

如果 auto_ptr 语义对您不起作用，则提升 shared_ptr

于 2010-02-02T19:35:03.957 回答
0

使用 plainstd::string或boost::scoped_array用于本地数组，或boost::shared_array用于共享字符串（后者允许您提供自定义删除器来调用free().）

于 2010-02-02T19:38:43.277 回答