努力编写 C API 的线程安全 C++ 包装器

Question

我正在编写 C API 的“线程安全”C++ 包装器，而 API 本身不是内部线程安全的。我尝试过使用 RAII。

我想知道，我的实现是否正确？以及它是否是线程安全的。我感谢我的代码中的任何 cmets。提前致谢！

要包装的C API如下，

 /* an data structure which represents a connection proxy to the logger: */
struct cLog_Logger;

/* connect the logger, and returns a handle to it: */
cLog_Logger* cLog_connect();

/* appends a zero terminated string to the log: */
void cLog_write(cLog_Logger* logger, const char* message);

/* closes the connection with the logger: */
void cLog_close(cLog_Logger* logger);

我的包装器实现如下：

    class LoggerWrapper{

    public:
        LoggerWrapper(){              //constructor
            cLog= cLog_connect();
        }

        void log(const std::string &message){    //entry point
            cLog_write(cLog, message);
            cLog_close(cLog);
            }

        ~LoggerWrapper(){        //destructor
            delete cLog;
        }
    protected:
         cLog_Logger *cLog;
}

谢谢！

Answer 1

我认为您需要像这样更改实现：

class LoggerWrapper{

public:
    LoggerWrapper(){              //constructor
        cLog= cLog_connect();
    }

    void log(const std::string &message){    //entry point
        cLog_write(cLog, message);
        }

    ~LoggerWrapper(){        //destructor
        cLog_close(cLog);
        delete cLog;
    }
protected:
     cLog_Logger *cLog;
} ;

这使您可以编写如下代码：

LoggerWrapper logger ;
logger.log("Something") ;
logger.log("Something else) ;

所以用同一个对象制作多个日志；否则第一次调用会关闭记录器并且对象是无用的。这是你想要的吗？

然后是第二个问题：线程安全是什么意思？您想从不同线程对同一个对象进行日志记录吗？

然后你可以像这样在日志函数中添加一个互斥锁和一个锁守卫：

class LoggerWrapper{

public:
    LoggerWrapper(){              //constructor
        cLog= cLog_connect();
    }

    void log(const std::string &message){    //entry point
        std::lock_guard<std::mutex> guard(mutex);
        cLog_write(cLog, message);
        }

    ~LoggerWrapper(){        //destructor
        cLog_close(cLog);
        delete cLog;
    }
protected:
     cLog_Logger *cLog;
     std::mutex mutex ;
} ;

Answer 2

简短回答：不，不是。一开始我觉得肯定是free()而不是delete，因为是c api。 您所做的可以使您的程序无资源泄漏，但不是线程安全的。 RAII 是为了避免资源泄漏。 有一种简单但低效的方法来包装您的 API 以实现线程安全，以便在您的 RAII 类中添加静态互斥锁。

#include <mutex>

class LoggerWrapper{

public:
    LoggerWrapper() : l(globalLock);
    {              //constructor
        cLog= cLog_connect();
    }

    void log(const std::string &message){    //entry point
        cLog_write(cLog, message);
        cLog_close(cLog);
        }

    ~LoggerWrapper(){        //destructor
        free(cLog); // I think here must be free(), but not sure
    }
protected:
    cLog_Logger *cLog;
    static std::mutex globalLock;
    std::lock_guard<std::mutex> l;
}

std::mutex LoggerWrapper::globalLock;