Usage of a C library in a C++ project (std::string char array conversion) Abstract

I have little C/C++ skills.  I've learned programming mainly with Java, and so I chose C++ (targeting C++11) as the language to learn better. In my current C++ project, I have to use the discount C library for its Markdown functions.

To explain briefly my code: the member variable std::string markdown_ is the Markdown I want to "compile" to HTML. To do so, I have to use the following functions from discount:


MMIOT *mkd_string(char *string, int size, int flags);
int mkd_compile(MMIOT *document, int flags);
int mkd_document(MMIOT *document, char **doc);
mkd_css and mkd_toc are alike mkd_document


Questions


As you see, I need to copy the markdown_ string and make it a char*. To do so, I used a std::vector as suggested in Converting an std::string into a char array, but I would like to know if doing it this way is appropriate in my case, or if there are other ways to achieve that.
MMIOT *mkd_string(char *string, int size, int flags); is defined in the main page to return null on error. Is it correct to use nullptr like I do in the following code to check the return value?
Do you have suggestions to improve this code, or does it looks good?


Code extract



const std::string Markdown::error_msg_mkd_string = "libmarkdown failed to "
    "parse the following Markdown:\n";

void Markdown::compile()
{
    MMIOT* doc;
    int size;
    char *cstr_buff;
    int flags = MKD_TOC|MKD_SAFELINK|MKD_EXTRA_FOOTNOTE;

    std::vector&lt;char&gt; buff(markdown_.cbegin(), markdown_.cend());
    doc = mkd_string(&amp;buff[0], buff.size(), flags);

    if(doc == nullptr)
        throw std::runtime_error(
            std::string(error_msg_mkd_string)
                .append(&amp;buff[0], buff.size())
            );

    mkd_compile(doc, flags);

    // It is not a bad practice to reuse 'size' and 'cstr_buff' like in the
    // following code, or is it?
    size = mkd_css(doc, &amp;cstr_buff);
    css_.assign(cstr_buff, size);

    size = mkd_document(doc, &amp;cstr_buff);
    html_.assign(cstr_buff, size);

    size = mkd_toc(doc, &amp;cstr_buff);
    toc_.assign(cstr_buff, size);

    mkd_cleanup(doc);
}
If mkd_string accepts a const char*, then you are better off using a std::string and its method c_str() to pass the value to the function. Otherwise your solution is correct.
Yes. See this answer for the why. Or build this code (tested with g++ -std=c++0x, gcc version 4.6):

#include &lt;iostream&gt;
int main()
{
    if (NULL == nullptr)
        std::cout &lt;&lt; "NULL == nullptr\n";   
}

Declare the variable immediately before using it, possibly also defining it. This reduces its scope to the minimum, helps the reader/maintainer of the code understanding what the variable is for, and avoids terrible errors deriving from forgetting to initialize variables. (This should also provide you with some guideline for the question about re-using the same variable twice in the same block.)