I need to better understand unique_ptr; allow me to pick your brain

I wrote some code that produces this:

Code:

---

1>c:\users\comp sci\documents\visual studio 2010\projects\predatorpreysimulation\predatorpreysimulation\world.h(25): error C2665: 'std::vector<_Ty>::vector' : none of the 7 overloads could convert all the argument types
1>          with
1>          [
1>              _Ty=World::UniqueOrganism
1>          ]
1>          c:\microsoft visual studio 10.0\vc\include\vector(521): could be 'std::vector<_Ty>::vector(unsigned int,const _Ty &)'
1>          with
1>          [
1>              _Ty=World::UniqueOrganism
1>          ]
1>          while trying to match the argument list '(int, nullptr)'
1>
1>Build FAILED.

---

The code producing such errors is:

Code:

---

class World{

        struct UniqueOrganism{
                std::unique_ptr<Organism> unique_organism;
               
                UniqueOrganism() {}

                // Move constructor
                UniqueOrganism(UniqueOrganism &object){
                        unique_organism = std::move(object.unique_organism);
                }
        };

        std::vector<std::vector<UniqueOrganism>> cell_grid;

public:
        World() {
                cell_grid = std::vector<std::vector<UniqueOrganism>> (20, std::vector<UniqueOrganism>(20, nullptr));
        }
        ~World() {}

};

---

I know there is no copy/assign with unique_ptr. There is also no copy constructor with unique_ptr and that unique_ptr owns the object without reference counting. What is lacking in my understanding?

What I am uncertain of is unique_ptr can reside within a container. Because copy/assign is not supported, I chose to embed the unique_ptr inside a class

I tried rearranging my code:

Code:

---

class World{

        struct UniqueOrganism{
                std::unique_ptr<Organism> unique_organism;
               
                UniqueOrganism() {}

                // Move constructor
                UniqueOrganism(UniqueOrganism &object){
                        unique_organism = std::move(object.unique_organism);
                }
        };

        std::vector<std::vector<UniqueOrganism>> cell_grid;
public:
        World() : cell_grid(20, std::vector<UniqueOrganism>(20)) {}
        ~World() {}
};

---

and received familiar errors related to trying to invoke the private copy constructor on initialization of cell_grid:

Code:

---

1>c:\users\comp sci\documents\visual studio 2010\projects\predatorpreysimulation\predatorpreysimulation\world.h(20): error C2248: 'std::unique_ptr<_Ty>::operator =' : cannot access private member declared in class 'std::unique_ptr<_Ty>'
1>          with
1>          [
1>              _Ty=Organism
1>          ]
1>          c:\microsoft visual studio 10.0\vc\include\memory(2352) : see declaration of 'std::unique_ptr<_Ty>::operator ='
1>          with
1>          [
1>              _Ty=Organism
1>          ]
1>          This diagnostic occurred in the compiler generated function 'World::UniqueOrganism &World::UniqueOrganism::operator =(const World::UniqueOrganism &)'
1>
1>Build FAILED.

---

What you comment as a move constructor is a copy constructor instead. A move constructor would have an rvalue reference parameter.

Quote:

---

Originally Posted by Imanuel

What I am uncertain of is unique_ptr can reside within a container.

---

The C++11 version of various standard containers allow for that.

While you can use move-only objects (such as unique_ptr) in containers, some methods of the containers have more extensive requirements, i.e. they require the element type to be copyable and not just movable.

The (size_type n, E e) constructor of vector is one such. This should be fairly obvious: the constructor makes the vector n elements large and initializes each of these elements to be a copy of e. If E isn't copyable, that's not going to fly.

Quote:

---

Originally Posted by CornedBee

While you can use move-only objects (such as unique_ptr) in containers, some methods of the containers have more extensive requirements, i.e. they require the element type to be copyable and not just movable.

The (size_type n, E e) constructor of vector is one such. This should be fairly obvious: the constructor makes the vector n elements large and initializes each of these elements to be a copy of e. If E isn't copyable, that's not going to fly.

---

I actually already understood that ... the primary reason for my compile-time errors. My question was eliciting how to use a unique_ptr inside a container when every container has a copy constructor which violates unique_ptr no copy/no assignment?

You don't necessarily need to avoid STL containers, it is only that for once you will have to pay attention to avoid operations that make copies.

I am certain that a vector can be default constructed and then you can push_back as many unique pointers as you want.

Quote:

---

Originally Posted by whiteflags

You don't necessarily need to avoid STL containers, it is only that for once you will have to pay attention to avoid operations that make copies.

I am certain that a vector can be default constructed and then you can push_back as many unique pointers as you want.

---

Can you provide a complete example?

I can, but I won't.

vector::vector - C++ Reference
Pay attention to the demonstration of vector's constructors on this page and recognize that one of them is the default one.

vector::push_back - C++ Reference
Recognize that the C++11 version of this function uses move semantics.

Welcome to the wonderful world of reading.

Quote:

---

Originally Posted by Imanuel

I actually already understood that ... the primary reason for my compile-time errors. My question was eliciting how to use a unique_ptr inside a container when every container has a copy constructor which violates unique_ptr no copy/no assignment?

---

As long as you don't instantiate the container's copy constructor (i.e. never try to copy the container), that doesn't matter.