Fast-resizing uint8 buffer

// buffer which should be faster than std::vector<uint8_t> when resizing a lot because it does not do byte initialization when resizing 

This comment line is really long. You should wrap the text so that there is no horizontal scrollbar anymore.

class uint8_fast_buffer { public: uint8_fast_buffer(const size_t initial_size) 

Undeclared identifier size_t. You forgot to post the #include lines; they are required for a good code review.

 { if(initial_size == 0) 

There's a space missing between the if and the open parenthesis.

 { // .. i don't really like the idea of buf being nullptr, this avoids that issue. this->internal_reserve(1); } else { this->internal_reserve(initial_size); this->buf_size=initial_size; } } 

The above constructor can be written in a shorter way, like this:

 uint8_fast_buffer(const size_t initial_size) { this->buf_size = initial_size; this->internal_reserve(std::max(initial_size, 1)); } 

Continuing with your code:

 ~uint8_fast_buffer() noexcept { free(this->buf); } size_t size(void) noexcept 

The void is not necessary inside the parentheses. Remove it.

 { return this->buf_size; } void reserve(const size_t reserve_size) { if(reserve_size > this->buf_size_real) { this->internal_reserve(reserve_size); } } // this function is supposed to be very fast when newlen is smaller than the biggest it has ever been before. void resize(const size_t newlen) { if(__builtin_expect(newlen > this->buf_size_real,0)) 

There's a space missing after the if, and after the comma.

 { this->internal_reserve(newlen); } this->buf_size=newlen; } void append(const uint8_t *data, const size_t len){ 

There's a newline missing before the {. You should let your IDE format the source code, to avoid these inconsistencies.

 const size_t pos=this->size(); const size_t new_pos=this->size()+len; this->resize(new_pos); memcpy(&this->buf[pos],data,len); 

Therearespacesmissingallovertheplaceespeciallyaroundtheoperators.

 } void reset(void) noexcept { this->buf_size=0; } bool empty(void) noexcept { return (this->buf_size==0); } 

The parentheses are not necessary.

 uint8_t* data(void) noexcept { return this->buf; } uint8_t& at(const size_t pos) { if(__builtin_expect(pos >= this->size(),0)) { throw std::out_of_range(std::to_string(pos)+std::string(" >= ")+std::to_string(this->size())); } return this->buf[pos]; } uint8_t& operator[](const size_t pos) noexcept { return this->buf[pos]; } private: void internal_reserve(const size_t reserve_size) { uint8_t *newbuf=(uint8_t*)realloc(this->buf,reserve_size); if(__builtin_expect(newbuf == nullptr,0)) { throw std::bad_alloc(); } this->buf_size_real=reserve_size; this->buf=newbuf; } size_t buf_size=0; size_t buf_size_real=0; 

To clearly distinguish buf_size and buf_size_real, the Go programming language uses buf_len and buf_cap (for capacity). The word real is rather confusing.

 uint8_t *buf=nullptr; }; 

Summary

On a high level, the code looks good. It works, takes care of exceptional situations and defines a minimal and appropriate API.

On the syntactic level, there are many small details that can be improved, like consistent formatting and variable names.

Let your IDE take care of the formatting, write some unit tests, and you're fine.