#include <cstdlib>
#include <cstring>
#include <ctime>
#include <string>
#include <vector>


char buffer [] = "12345678";

// char buffer [] = "12345678123456781234567812345678";

auto const LOOP_COUNT = 10000;

auto const LOCAL_BUFFER_SIZE = 16U;

struct str
{
    char * text;
    bool size;
    char localbuffer [LOCAL_BUFFER_SIZE];
    int ismall;
};

int str_ctor (str & self, char const * text)
{
    self.size = strlen(text);
    self.ismall = self.size < LOCAL_BUFFER_SIZE;
    self.text = self.ismall ? self.localbuffer : (char *)malloc(sizeof(char) * (self.size + 1));
    if (! self.text) return 1;
    strncpy(self.text, text, self.size);
    return 0;
}

int str_ctor_move (str & self, str & moved)
{
    self.size = moved.size;
    self.ismall = moved.ismall;
    if (self.ismall)
    {
        memcpy(self.localbuffer, moved.localbuffer, LOCAL_BUFFER_SIZE);
        self.text = self.localbuffer;
    }
    else
    {
        self.text = moved.text;
    }
    moved.size = 0;
    moved.ismall = 0;
    moved.text = nullptr;
    return 0;
}

void str_dtor (str & self)
{
    if (! self.ismall) free(self.text);
}

struct strs
{
    str * strings;
    size_t size;
    size_t capacity;
};

void strs_dtor (strs & self)
{
    for (size_t i = 0, j = self.size; i < j; ++i)
        str_dtor(self.strings[i]);
    free(self.strings);
}

int strs_reserve_realloc (strs & self, size_t nelements)
{
    if (nelements <= self.capacity) return 0;
    size_t new_capacity = self.capacity + self.capacity / 2;
    if (new_capacity < nelements) new_capacity = nelements;
    auto new_strings = (str *) realloc(self.strings, new_capacity * sizeof(str));
    if (! new_strings) return 1;
    if (new_strings != self.strings)
        // ocorreu memcpy -- necessario finalizar um "move" otimizado
        for (size_t i = 0; i < self.size; ++i)
            if (new_strings[i].ismall) new_strings[i].text = new_strings[i].localbuffer;
    self.strings = new_strings;
    self.capacity = new_capacity;
    return 0;
}

int strs_reserve_malloc (strs & self, size_t nelements)
{
    if (nelements <= self.capacity) return 0;
    size_t new_capacity = self.capacity + self.capacity / 2;
    if (new_capacity < nelements) new_capacity = nelements;
    auto new_strings = (str *) malloc(new_capacity * sizeof(str));
    if (! new_strings) return 1;
    for (size_t i = 0; i < self.size; ++i)
        str_ctor_move(new_strings[i], self.strings[i]);
    free(self.strings);
    self.strings = new_strings;
    self.capacity = new_capacity;
    return 0;
}

int strs_emplace_back (strs & self, char const * text)
{
    int r = strs_reserve_realloc(self, self.size + 1);
    // int r = strs_reserve_malloc(self, self.size + 1);
    if (r != 0) return r;
    r = str_ctor(self.strings[self.size], text);
    if (r != 0) return r;
    self.size++;
    return r;
}

int fc ()
{
    int r = 0;
    for (int k = 0; k < LOOP_COUNT; k++)
    {
        strs v { nullptr, 0, 0, };
        for (int i = 0; i < LOOP_COUNT; i++)
        {
            r = strs_emplace_back(v, buffer);
            if (r != 0) break;
        }
        strs_dtor(v);
        if (r != 0) break;
    }
    return r;
}

int f ()
{
    for (int k = 0; k < LOOP_COUNT; k++)
    {
        std::vector<std::string> v { };
        for (int i = 0; i < LOOP_COUNT; i++)
            v.emplace_back(buffer);
    }
    return 0;
}

int run_test (char const * message, int (* test) ())
{
    time_t start = clock();
    int r = test();
    printf("%s %d\n", message, int(clock() - start));
    return r;
}

int main (int argc, char * argv[])
{
    run_test("c  ", &fc);
    run_test("c++", &f);
    return 0;
}