file input and pointer ownership semantics

Question

There are two ways that I know of to read file contents to a C-style string. The reason I need a C-style string and not a unique_ptr<string> is because I will be passing this data to a C function, gumbo_parse() whose parameter is a C-style string, and this way I avoid the overhead of a unique_ptr<string>. I am open to arguments against my decision.

std::ifstream ifs(bf::path("..."));                                              // Input file stream

First way:

std::filebuf * ptr_fbuff = ifs.rdbuf();                                         // Buffer to file contents.
std::size_t fbuff_size = ptr_fbuff->pubseekoff(0, ifs.end, std::ios_base::in);  // Get offset from 0 to end of buffer.
ptr_fbuff->pubseekpos(0, std::ios_base::in);                                    // Move buffer position back to beginning.
char * buffer = new char[fbuff_size];                                           // Buffer to store file data.
ptr_fbuff->sgetn(buffer, fbuff_size);                                           // Get file data.

Second way:

std::stringstream sstm_buffer;                                                  // Buffer to file contents.
sstm_buffer << ifs.rdbuf();                                                     // Read file contents to sstm.
const std::string & str_buffer = sstm_buffer.str();                             // Get underlying string from sstm.
char * buffer = new char[str_buffer.size()];                                    // Buffer to store file data.
str_buffer.copy(buffer, str_buffer.size());                                     // Copy file contents to buffer.

Do stuff:

GumboOutput * ptr_outpt = gumbo_parse(buffer);
//...

Close file:

gumbo_destroy_output(&kGumboDefaultOptions, ptr_outpt);
ifs.close();                                                                    // Close stream to file.
delete[] buffer;                                                                // Delete allocated buffer.

What are the differences between the two in terms of memory cost and speed. Clearly one uses a Stringstream as a buffer before putting the contents into the C-style string, and the other uses a filebuf before putting the contents into a C-style string.

Now to my second question. Ownership semantics and memory allocation. Does the ifstream allocate any memory in the heap for the buffer returned from rdbuf? Am I responsible for deleting the buffer returned from rdbuf? If it doesn't, say I'm reading a huge file... isn't that potentially a LOT of data to be storing in the stack?

Edit:

std::unique_ptr<std::string> mytype::my_func(const std::string & path)
{
    std::ifstream ifs(path);                                            // Input file stream
    std::stringstream sstm_buffer;                                      // Buffer to file contents.
    sstm_buffer << ifs.rdbuf();                                         // Read file contents to sstm.
    ifs.close();                                                        // Close stream to file.
    auto ptr_buffer = std::make_unique<std::string>(sstm_buffer.str()); // Pointer to copy of sstm buffer contents.
    return std::move(ptr_buffer);                                       // Return pointer.
}

Edit2:

std::string mytype::my_func(const std::string & path) const
{
    std::ifstream ifs(path);
    std::stringstream sstm_buf;
    sstm_buf << ifs.rdbuf();
    ifs.close();
    return sstm_buf.str();
}

Edit3:

std::string psclient::file_get(const std::string & path) const
{
    std::ifstream ifs(path);    // Stream to file (Automatically close() on ~).
    std::ostringstream reader;  // Stream to read file contents.
    reader << ifs.rdbuf();      // Read in file contents.
    return reader.str();        // Return a move instead of copy (Done implicitly).
}

Answer 1

The reason I need a C-style string and not a unique_ptr is because I will be passing this data to a C function

You can still get a C-style pointer, for example

#include <iostream>
#include <string>
#include <memory>

void print_C_style_string(const char* psz)
{
    printf("str = %s", psz);
}

int main()
{
    std::unique_ptr<std::string> p{new std::string{"This is a string!"}};
    print_C_style_string(p.get()->c_str());
    return 0;
}

There is no overhead with unique_ptr. From "The C++ Programming Language" by Bjarne Stroustrup:

unique_ptr is a very lightweight mechanism with no space or time overhead compared to correct use of a built-in pointer.

Simple way of reading file line-by-line into string:

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main()
{
    ifstream fin("my_file.txt", ios::in);
    if(!fin){
        printf("Error opening file.");
        return 1;
    }

    while(fin.peek() != EOF){
        string s;
        getline(fin, s);
        cout << s << std::endl;
    }

    fin.close();

    return 0;
}

Answer 2

When you're writing modern C++, there is a particular set of cases that require the use of pointers, but this isn't one of them. You should always prefer not to use them, when you don't have to. Return value optimization (RVO) and RAII are wonderful things!

By default, an std::string created on the stack uses the heap to store its internal character data; so there's no need to worry limited stack memory in your situation. Additionally, std::string::c_str() will return the string's internal const char* data, which is exactly what gumbo_parse() accepts as an argument.

This simplifies the code required to read your file. RVO will prevent unnecessary copies, increasing performance:

std::string get_file_contents(const std::string& filename)
{
    std::ifstream ifs{filename}; // Open the input file stream
    std::ostringstream ss;       // stringstream to retrieve file data
    ss << ifs.rdbuf();           // Read file data into ss buffer
    return ss.str();             // Return the ss buffer as string (RVO)
}

Now you don't have to worry about explicitly freeing any memory. You can use the above function and pass the resulting string's c_str() to gumbo_parse():

const std::string file_contents{get_file_contents("input.txt")};

GumboOutput* output = gumbo_parse(file_contents.c_str());

// ...

gumbo_destroy_output(&kGumboDefaultOptions, output);

---

If you really did want to experiment with smart pointers somewhere, you could try wrapping your GumboOutput in one with a custom deleter; something like this:

using namespace std::placeholders;  // for _1, _2, _3 ...
auto cleanup = std::bind(gumbo_destroy_output, &kGumboDefaultOptions, _1);
std::unique_ptr<int, decltype(cleanup)> output{
    gumbo_parse(file_contents.c_str()), cleanup };

The unique_ptr will now automatically call gumbo_destroy_output on its managed GumboOutput when it is destroyed (i.e., when it goes out of scope). Use this at your own discretion.