在函数中返回无符号字符数组，但不返回指针

Question

I am implementing a simple class in C++ which have only one attribute that has to be unsigned char array and two methods, one get and one set. I am struggling to define this unsigned char array. I defined the attributed as a pointer, but the get method cannot return a pointer because this is an undefined behavior. So what should I return? and address? If I use & the class does not compile.

Ho to implement this class to not return a pointer to the local ´unsigned char array´?

ps: I am not using std::vector<unsigned char> or other types because it increases 10 time to return the value. With char array I got 0.005 milliseconds and with std::vector<unsigned char> I got 0.07 milliseconds.

class SkinnyBuffer {
private:
    unsigned char* _value;
public:
    ~SkinnyBuffer();
    SkinnyBuffer();
    void setBufferValue(unsigned char value[]);
    unsigned char& getBufferValue();;
};

#include "utils/SkinnyBuffer.h"

SkinnyBuffer::~SkinnyBuffer() {
}
SkinnyBuffer::SkinnyBuffer() {
}
void SkinnyBuffer::setBufferValue(unsigned char value[]) {
    _value = value;
}
unsigned char SkinnyBuffer::getBufferValue() {
    return _value;
}

Answer 1

The question is a little underspecified but does open up some possibilities.

First of all, you need to decide these things:

• Do you want to store an array, or a pointer?
  • Currently you're storing a pointer, though it may point to an array.
• Do you want to return an array, or a pointer to its first element?
  • You can't return an array
  • You can return a pointer in this case (it's not UB, but getBufferValue needs to return a unsigned char* in order for this to compile), but do you want to?

If the bounds of the SkinnyBuffer can change, then storing a pointer to some dynamically allocated memory is appropriate. You should instead use a std::vector for this purpose, and accessing a vector is not slower despite your claims — you must have accidentally copied it somewhere or done some other inefficient thing. So you can explore that further.

As for returning values, well again this depends on what you want. It may be more logical to implement an operator[] that provides element-like access to the buffer. But, then, why wrap the vector at all? Just have a vector!

If you do want to return a pointer, you won't be able to assign this to an object of array type (despite what Robert's answer claims); you'd have to use std::copy (or a related technique) to copy its elements one at a time. This is a limitation inherited from C, which does not permit direct array assignment. Also note that the returned pointer will be "weak" but also not clearly describe this to the programmer writing code at the call site, which is dangerous; a smart pointer would make this better.

Finally, the core of your problem is that this all applies to setBufferValue , too. Your input into the class just copies a pointer, and who knows what that points to? Again, a vector will make your life much easier.

Ultimately there are plenty of choices here and the "right" choice depends on your actual requirements and what you want to do with this data.

Answer 2

This is a more reasonable approach. Although, it is not good either. You should implement the constructor and destructor. The way to do it is to return a pointer. You can't return an entire array. Although you should keep an extra field for the size of the array.

class SkinnyBuffer {
private:
    unsigned char* _value;
public:
    ~SkinnyBuffer();
    SkinnyBuffer();
    void setBufferValue(unsigned char value[], size_t n);
    unsigned char* getBufferValue();
};

// imagine this is the cpp file down here

void SkinnyBuffer::setBufferValue(unsigned char value[], size_t n) {
    if(_value != nullptr)
      delete [] _value;
    _size = n; // assume _size is a field
    _value = new unsigned char[_size];
    std::copy(value, value + n, _value);
}

unsigned char* SkinnyBuffer::getBufferValue() {
    return _value;
}

Answer 3

First of all, your setBufferValue will set _value to point to the same address of the passed array. It will not copy it, so be careful dealing with it

Now, for getBufferValue , it must be declared as:

unsigned char * getBufferValue();

and

unsigned char * SkinnyBuffer::getBufferValue() {