Create a std::vector of std::vectors of class without copy constructor

Question

I want to create a std::vector<std::vector<LibraryClass>> where LibraryClass is not available to me for modifcation, and has no copy constructor.

For a std::vector<LibraryClass>, the following code compiles:

#include <vector>

class LibraryClass {
    public:
        LibraryClass() {};
        LibraryClass(const LibraryClass&) = delete;     
};

class MainClass {
    public:
        MainClass(int); 
        std::vector<LibraryClass> collection;
};

MainClass::MainClass(int nx)
: collection( nx ) { 
}

int main() {        
    MainClass main_class(3);    
}

But with a std::vector<std::vector<LibraryClass>>, it doesn't (use of deleted function - the copy constructor):

#include <vector>

class LibraryClass {
    public:
        LibraryClass() {};
        LibraryClass(const LibraryClass&) = delete;     
};

class MainClass {
    public:
        MainClass(int, int);    
        std::vector<std::vector<LibraryClass>> collection;
};

MainClass::MainClass(int nx, int ny)
: collection( nx, std::vector<LibraryClass>(ny) ) { 
}

int main() {        
    MainClass main_class(3, 4); 
}

What can I do to achieve this?

Thanks you in advance.

EDIT: After compiling with g++ -o test_vec_of_ves test_vec_of_vecs.cpp the exact error is :


In file included from /usr/include/c++/7/vector:62:0,
                 from test_vec_of_vecs.cpp:1:
/usr/include/c++/7/bits/stl_construct.h: In instantiation of ‘void std::_Construct(_T1*, _Args&& ...) [with _T1 = LibraryClass; _Args = {const LibraryClass&}]’:
/usr/include/c++/7/bits/stl_uninitialized.h:83:18:   required from ‘static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const LibraryClass*, std::vector<LibraryClass> >; _ForwardIterator = LibraryClass*; bool _TrivialValueTypes = false]’
/usr/include/c++/7/bits/stl_uninitialized.h:134:15:   required from ‘_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const LibraryClass*, std::vector<LibraryClass> >; _ForwardIterator = LibraryClass*]’
/usr/include/c++/7/bits/stl_uninitialized.h:289:37:   required from ‘_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = __gnu_cxx::__normal_iterator<const LibraryClass*, std::vector<LibraryClass> >; _ForwardIterator = LibraryClass*; _Tp = LibraryClass]’
/usr/include/c++/7/bits/stl_vector.h:331:31:   required from ‘std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&) [with _Tp = LibraryClass; _Alloc = std::allocator<LibraryClass>]’
/usr/include/c++/7/bits/stl_construct.h:75:7:   required from ‘void std::_Construct(_T1*, _Args&& ...) [with _T1 = std::vector<LibraryClass>; _Args = {const std::vector<LibraryClass, std::allocator<LibraryClass> >&}]’
/usr/include/c++/7/bits/stl_uninitialized.h:210:18:   required from ‘static _ForwardIterator std::__uninitialized_fill_n<_TrivialValueType>::__uninit_fill_n(_ForwardIterator, _Size, const _Tp&) [with _ForwardIterator = std::vector<LibraryClass>*; _Size = long unsigned int; _Tp = std::vector<LibraryClass>; bool _TrivialValueType = false]’
/usr/include/c++/7/bits/stl_uninitialized.h:255:17:   required from ‘_ForwardIterator std::uninitialized_fill_n(_ForwardIterator, _Size, const _Tp&) [with _ForwardIterator = std::vector<LibraryClass>*; _Size = long unsigned int; _Tp = std::vector<LibraryClass>]’
/usr/include/c++/7/bits/stl_uninitialized.h:366:39:   required from ‘_ForwardIterator std::__uninitialized_fill_n_a(_ForwardIterator, _Size, const _Tp&, std::allocator<_Tp2>&) [with _ForwardIterator = std::vector<LibraryClass>*; _Size = long unsigned int; _Tp = std::vector<LibraryClass>; _Tp2 = std::vector<LibraryClass>]’
/usr/include/c++/7/bits/stl_vector.h:1342:33:   required from ‘void std::vector<_Tp, _Alloc>::_M_fill_initialize(std::vector<_Tp, _Alloc>::size_type, const value_type&) [with _Tp = std::vector<LibraryClass>; _Alloc = std::allocator<std::vector<LibraryClass> >; std::vector<_Tp, _Alloc>::size_type = long unsigned int; std::vector<_Tp, _Alloc>::value_type = std::vector<LibraryClass>]’
/usr/include/c++/7/bits/stl_vector.h:298:27:   required from ‘std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>::size_type, const value_type&, const allocator_type&) [with _Tp = std::vector<LibraryClass>; _Alloc = std::allocator<std::vector<LibraryClass> >; std::vector<_Tp, _Alloc>::size_type = long unsigned int; std::vector<_Tp, _Alloc>::value_type = std::vector<LibraryClass>; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<std::vector<LibraryClass> >]’
test_vec_of_vecs.cpp:17:49:   required from here
/usr/include/c++/7/bits/stl_construct.h:75:7: error: use of deleted function ‘LibraryClass::LibraryClass(const LibraryClass&)’
     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test_vec_of_vecs.cpp:6:3: note: declared here
   LibraryClass(const LibraryClass&) = delete;
   ^~~~~~~~~~~~

Please quote the exact error you get and the line(s) it implicates, and mention which compiler/settings give that. I instead get this with `g++` - `include/c++/9.3.0/bits/stl_uninitialized.h:127:72: error: static assertion failed: result type must be constructible from value type of input range`. It does go away if commenting out the `delete` of the copy ctor. — underscore_d, Jun 16 '20 at 10:25
Does this answer your question? [Insert into vector having objects without copy constructor](https://stackoverflow.com/questions/19826376/insert-into-vector-having-objects-without-copy-constructor) If so, then I think that's just how it is, and if you have no way of adding a copy/move ctor, maybe you need to store `vectors` of `unique_ptr`s instead. — underscore_d, Jun 16 '20 at 10:30
@underscore_d: Unfortunately I cannot modify the LibraryClass (I put it there to make a minimum working example). Therefore, I also cannot add a move constructor. — Steffen Wolp, Jun 16 '20 at 10:34
So then I think you need to store it by `unique_ptr`, and redo your initialisation of the vectors of default-constructed elements by constructing with N elements of `std::make_unique()`. — underscore_d, Jun 16 '20 at 10:37
Ok, I figured it out I think. It took me a while, but it seems to work. I am adding the solution as an answer to the question. Thank you for your help! — Steffen Wolp, Jun 16 '20 at 13:07
You're welcome. Please instead post an answer, rather than editing the question, though. — underscore_d, Jun 16 '20 at 13:07
just my lack of understanding of the unique_ptr, whether the the default destructor takes care of it. But that's my lack of understanding of those concepts. — Steffen Wolp, Jun 16 '20 at 13:11

score 2 · Accepted Answer · answered Jun 16 '20 at 13:08

Following underscore_d's advice, here is a version that appears to work (including some function that shows that something is done).

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

class LibraryClass {
    public:
        LibraryClass() {};
        LibraryClass(const LibraryClass&) = delete;
        void init(int aa, int bb) { a = aa; b = bb; };
        void report() { std::cout << "I am " << a << " / " << b << std::endl; };        
    private: 
        int a, b;               
};

class MainClass {
    public:
        MainClass(int, int);                    
        void init();
        void report();              
        std::vector<std::vector<std::unique_ptr<LibraryClass>>> collection;
};

MainClass::MainClass(int nx, int ny) { 
    collection.resize(nx);
    for (int i=0; i<nx; ++i) {      
        collection[i].resize(ny);               
        for (int j=0; j<ny; ++j) {          
            collection[i][j] = std::make_unique<LibraryClass>();            
        }               
    }   
}

void MainClass::init() {
    for (int i=0; i<collection.size(); ++i) {           
        for (int j=0; j<collection[i].size(); ++j) {            
            collection[i][j]->init(i,j);            
        }                   
    }
}

void MainClass::report() {
    for (int i=0; i<collection.size(); ++i) {
        for (int j=0; j< collection[i].size(); ++j) {
            collection[i][j]->report();
        }
    }
}

int main() {
    int nx = 3;
    int ny = 4;
    MainClass main_class(nx, ny);       
    main_class.init();
    main_class.report();
}

Create a std::vector of std::vectors of class without copy constructor

1 Answers1