(FUZZING) Get a pointer to data range of dynamic array

EDIT: Clarification:

If I have an array int* a = new int[10], I want to get a pointer to a, but only the values from 0 to 5, without having to allocate another array for those values.

Original post:

I created a small class to fuzz my functions, but the thing is that it is painfully slow. It takes roughly 10-20 seconds to run my function 1000 times.

I decided to improve my code by allocating a very large array at first, then filling it from 0 to a randomly generated number and then just returning a pointer to that range to use in my function instead of allocating memory and deleting it each time.

Below is my code.

I attempt to allocate 1 million bytes at first, then I want to return a range from 0 to whatever size my class generated. Currently I allocate memory once more for returning it, but that's not efficient.

I use Xorshift to generate random numbers, which should be much faster than rand() so I think besides memory allocation it's pretty good, but any suggestions are very much welcome!

Note: if you do not understand part of my code ask me (it's written quickly, so it might be unintelligible at certain parts) ;)

class fuzz {
public:

    fuzz() {
        this->alloc_init_buff();
    }

    ~fuzz() {
        this->dealloc_init_buff();
    }

    int fill_buff(unsigned int size) {
        if (size > this->m_buffsize) { size = this->m_buffsize; }
        for (int i = 0; i < size; ++i) {
            this->m_buff[i] = this->rand_xor();
        }
        return size;
    }

    int fill_buff() {
        int size = this->rand_xor(1, this->m_buffsize);
        if (size > this->m_buffsize) { size = this->m_buffsize; }
        for (int i = 0; i < size; ++i) {
            this->m_buff[i] = this->rand_xor();
        }
        return size;
    }

    unsigned char*& get_buff(int size) {
        unsigned char* temp = new unsigned char[size];
        memcpy((void*)temp, (void*)this->m_buff, size);
        return temp;
    }

private:

    struct xr_xorshift_state {
        unsigned int a = 123456789, b = 362436069, c = 521288629, d = 88675123;
    };

    unsigned int xorshift(xr_xorshift_state* state) {
        unsigned int res = 0;
        res = state->a ^ (state->a << 11);
        state->a = state->b; state->b = state->c; state->c = state->d;
        state->d = state->d ^ (state->d >> 19) ^ (res ^ (res >> 8));
        res &= 0x7fffffff;
        return res;
    }

    unsigned int rand_xor() {
        return this->xorshift(&this->m_state);
    }

    unsigned int rand_xor(unsigned int min, unsigned int max) {
        return (min + (this->rand_xor() % (max - min)));
    }

    void alloc_init_buff() {
        this->m_buff = new unsigned char[this->m_buffsize];
    }

    void dealloc_init_buff() {
        delete[] this->m_buff;
    }

    xr_xorshift_state m_state = { 0 };
    unsigned char* m_buff = { 0 };
    unsigned int m_buffsize = { 1000000 };
};

int find_newline(const char* text, int size) {
    int pos = 0;
    while (*text != '\n') {
        if (pos == size) { return 0; }
        ++text; ++pos;
    }
    return pos;
}

int main() {
    fuzz fz = {};
    unsigned char* randdata = nullptr;
    int lap = 0;
    int th = 0;
    for (;;) {
        if (lap == 1000) {
            lap = 0;
            ++th;
            printf("%d thousand laps done!\n", th);
        }
        try {
            int size = fz.fill_buff();
            randdata = fz.get_buff(size);
            const char* d = (const char*)randdata;
            find_newline(d, size);
            delete[] randdata;
            ++lap;
        }
        catch (...) {
            printf("error!\n");
            ++lap;
        }
    }
    getchar();
    return 0;
}