将共享指针存储到向量中的数组

Question

I'm trying to store a shared pointer to a fixed size array in to a vector, I want to use a shared pointer because I must pass a pointer to the array to another class that will write in the array, and I want to have more than one array because I may have more instances of the writing class and each one needs an array to write to, they will write a lot of data in the arrays so moving them is not a good option.

std::shared_ptr<char> sp( new char [MAX_LENGTH], std::default_delete<  char[] >() );
arrayVect.push_back(sp);

the vector is defined as class member like:

std::vector< std::shared_ptr< char [ MAX_LENGTH ] > > arrayVect;

I'm getting the error:

 error: no matching function for call to ‘std::vector<std::shared_ptr<char [MAX_LENGTH]> >::push_back(std::shared_ptr<char []>&)’

I have tried different alternatives but none of them have worked, could you point out the correct way of doing it? or is there an alternative that I am missing? the writing class needs an array of chars for the write function so I think I'm stuck with array.

thanks!

Answer 1

I feel like shared ownership is the wrong model here. Conceptually, why would you want your workers to continue to work on an array if no one else is observing the result anymore?

So I'd have the arrayVect own the arrays and hand out pointers to the arrays to the workers. When it doesn't make sense to keep one of the arrays around, stop the worker first and then delete the array.

The easiest way to get that behavior is to make arrayVect a std::vector<std::unique_ptr<std::array<char, MAX_LENGTH>>> . Then the pointer to the underlying char[MAX_LENGTH] array that you can pass to a worker can be obtained by calling arrayVect[idx].get().data() .

By having the additional indirection through the unique_ptr the pointers to the arrays remain valid even if the vector is resized.

EDIT: Here is an example how that can work with unique_ptr s even though your workers also need a pointer to the array:

class Worker {
public:
    Worker(std::array<char, MAX_SIZE>* array)
        : _array{array} {
    }

    void perform_work() {
       function_that_requires_c_arrays(_array->data()); // maybe also a size parameter? 
    }

private:    
    std::array<char, MAX_SIZE>* _array;
};

int main() {
    std::vector<std::unique_ptr<std::array<char, MAX_SIZE>>> arrayVect;
    arrayVect.emplace_back(std::make_unique<std::array<char, MAX_SIZE>>()));

    Worker w{arrayVect.back().get()};
    w.perform_work();
}

Answer 2

Try declaring vector like below,

std::vector<std::shared_ptr<char> > arrayVect;

Actually, You are declaring vector incorrectly. Please try and check with above change. Hope it helps!

Answer 3

You can use std::vector<std::shared_ptr<char>> without the array notation. It is important that you then still use std::default_delete<char[]>() as the deleter. Here is a complete example.

#include <iostream>
#include <vector>
#include <memory>

#define MAX_LENGTH 10

int main() {
    std::vector<std::shared_ptr<char>> arrayVect;
    std::shared_ptr<char> sp(new char[MAX_LENGTH], std::default_delete<char[]>());
    arrayVect.push_back(sp);
    arrayVect.push_back(std::shared_ptr<char>(new char[MAX_LENGTH], std::default_delete<char[]>()));

    char q = 0;
    for (size_t x = 0; x < arrayVect.size(); ++x)
        for (size_t y = 0; y < MAX_LENGTH; ++y)
            arrayVect.at(x).get()[y] = ++q;

    for (size_t x = 0; x < arrayVect.size(); ++x)
        for (size_t y = 0; y < MAX_LENGTH; ++y)
            std::cout << int(arrayVect.at(x).get()[y]) << '\n'; // Int cast to print numbers, and not ASCII control characters
}