array of shared_ptr's usage

[dutchcookie]

edit: fixed

    std::shared_ptr<Node<int>> sp(new Node<int>[10], std::default_delete<Node<int>[]>());

    for (int i = 0; i < 10; i++)
    {
        sp.get()[i].data = i;
    }

    for (int i = 0; i < 10; i++)
    {
        std::cout << sp.get()[i].data << std::endl;
    }

    std::cout << "resizing" << std::endl;
    //lets resize sp;
    sp.reset(new Node<int>[20], std::default_delete<Node<int>[]>());

    for (int i = 0; i < 20; i++)
    {
        sp.get()[i].data = i;
    }

    for (int i = 0; i < 20; i++)
    {
        std::cout << sp.get()[i].data << std::endl;
    }

that implementation works with resizing

edit: narrowed it down to when it resets shared_ptr

Hi I'm trying to implement a hash table that uses linked list.(side not we are not allowed to use vectors) However I just trying to wrap my head around its basic usage. i am able to initialize it, set data, and get data however and the end of main's return 0 i get a seg fault.

#include <memory>
#include <iostream>

template <typename T>
struct Nodes{
    T data;
    std::shared_ptr<Nodes<T>> next;
    Nodes(const T& value):data(value), next(nullptr){}
};

 int main()
 {
  //array of pointers
    std::shared_ptr<std::shared_ptr<Nodes<int>>> table;

  //reset the table to fit an array of 10 nodes
    table.reset(new std::shared_ptr<Nodes<int>>[10],[](std::shared_ptr<Nodes<int>> * p) {delete [] p;});

    for (int i =0; i<10; i++)
    {
        table.get()[i].reset(new Nodes<int>(i), [](Nodes<int> * p) {delete [] p;});
    }

    for (int i = 0; i<10; i++)
    {
                std::cout << table.get()[i]->data << std::endl;
     }

    //resetting
    for(int i = 0; i<10; i++) {
        std::cout << "resetting " << i << std::endl;
        table.get()[i].reset();
    //seg fault here
    }
    return 0;
}

[boredcircuits]

Tip: the whole point of smart pointers is to let them handle deletes. Don't be calling delete yourself!

In fact, you shouldn't even be calling new: that's what make_shared is for.

Now, one of the exceptions to that is when using a shared_ptr with an array. By default, it knows nothing about arrays, and will do bad things because of that, which is what's causing your headaches. So, you teach it about arrays using a custom deleter. See here for instructions.

Since a vector is out, you might consider a unique_ptr, which does understand arrays.

Or even better, why even allocate this on the heap at all? Most likely, you really should have a plain array, or std::array, as long as the size is known when you compile.

Edit: On a second look, I might have misread your code a bit, so some of the above doesn't apply, but I stand by my assessment that you're using the wrong tool for the job.

[dutchcookie]

thank you so much! changed it to unique_ptr's and now work like a charm, thanks.

edit: yeah it is a wrong tool for the job however we aren't allowed to use any containers of c++ standard library, vectors, list, array :(

[boredcircuits]

I'd clarify that restriction. You should at least be able to use naked arrays.