32035
uchar*のvectorを保持する構造体のvectorのアロケートがどうしてもうまく行きません。  
main関数内のwhileの処理終了後にエラーが出ます。

main関数のwhileに入る前に

```

    auto &data = Shared::locate(smt);
    
```

を実行したら必ずWhile文終了後にエラーになります。(core dump)  
このエラーは何を意味しているのか検索しても出てきません。  
どういうときに出るエラーなのですか？

[![よくわからないエラー](https://i.stack.imgur.com/mFJdZ.png)](https://i.stack.imgur.com/mFJdZ.png)

```

    #include <cv.h>
    #include <cxcore.h>
    #include <highgui.h>
    #include <boost/interprocess/managed_shared_memory.hpp>
    #include <boost/interprocess/managed_mapped_file.hpp> // use for Coliru
    #include <boost/interprocess/containers/vector.hpp>   // boost/containers/vector.hpp
    #include <boost/interprocess/containers/string.hpp>   // boost/containers/string.hpp
    #include <iostream>
    #include <sys/time.h>
    #include <stdio.h>
    
     //                                                                    void_allocator;
    namespace bip = boost::interprocess;
    
    typedef unsigned char uchar;
    //Typedefs of allocators and containers
    typedef bip::managed_shared_memory::segment_manager                       segment_manager_t;
    typedef bip::allocator<void, segment_manager_t>  void_allocator;
    
    typedef void_allocator::rebind<uchar>::other                           uchar_allocator;
    typedef bip::vector<uchar, uchar_allocator>                                   uchar_vector;
    
    
    
    template <typename Alloc = std::allocator<uchar> >
    struct BasicInData {
    
        public:
            BasicInData(Alloc alloc = {}) : image(alloc)
            { }
    
            template <typename T>
            BasicInData(double x, int sizeImg, uchar_vector& image, Alloc alloc = {}) :
                x(x), sizeImg(sizeImg), image(alloc)
            { }
    
            double x = 0;
            int sizeImg = 0;
            uchar_vector image;
    };
    
    using InData = BasicInData<>; // just heap allocated
    
    namespace Shared {
        using segment                      = bip::managed_shared_memory;
        using segment_manager              = segment::segment_manager;
    
        template <typename T> using alloc  = bip::allocator<T, segment_manager>;
        template <typename T> using vector = bip::vector<T, alloc<T> >;
    
        using InData = BasicInData<alloc<uchar> >; // shared memory version
    
        vector<InData>& locate(segment& smt) {
            auto* v = smt.find_or_construct<vector<InData> >("InDataVector")(smt.get_segment_manager());
            assert(v);
            return *v;
        }
    }
    
    
    int main(int argc, char* argv[]) {
    
        if(argc == 1){ //Parent process
            // Remove shared memory on construction and destruction
            bip::shared_memory_object::remove("MySharedMemory");
            // Create a new segment with given name and size
            struct timeval tv;
            gettimeofday(&tv, NULL);
            struct shm_remove
            {
                shm_remove(){bip::shared_memory_object::remove("MySharedMemory");}
                ~shm_remove(){bip::shared_memory_object::remove("MySharedMemory");}
            }remover;
            Shared::segment smt(bip::create_only,"MySharedMemory", 100000000);
            auto &data = Shared::locate(smt);
            //Shared::alloc bip::alloc_inst (data);
    
            cv::Mat_<cv::Vec3b> mat;
            cv::VideoCapture vcap(0);
    
            Shared::InData id(smt.get_segment_manager());
    
    
            if (!vcap.isOpened())
                return -1;
            char count = 0;
            while (1) {
                vcap >> mat;
                printf ("count: %d \n", count); count++;
                int image_size = mat.total() * mat.elemSize();
                printf ("size: %d \n", image_size);
                id.sizeImg = image_size;
                printf ("id's sizeImg: %d \n", id.sizeImg * sizeof(uchar));
                id.image.resize(image_size * sizeof(uchar));
                int totalSize = image_size * sizeof(uchar);
                printf ("count: %d \n", count);
                memcpy(&id.image[0], mat.data, image_size * sizeof(uchar));
                //Launch child process
                gettimeofday(&tv, NULL);
                double time = ((double)tv.tv_usec/1000000);
                id.x = time;
                data.push_back(id);
                if((100000000 / count) <= (totalSize*20)){ printf("Getting video data done"); break; }
            }
    
            std::string s(argv[0]); s += " child";
            if(0 != std::system(s.c_str()))
                return 1;
    
            // check child has destroyed the vector
            if(smt.find<Shared::vector<InData>>("InDataVector").first)
                return 1;
    
        } else{
            // Open the managed segment
            bip::managed_shared_memory segment(bip::open_only, "MySharedMemory");
    
            // Find the vector using c-string name
            bip::vector<InData> *myvector = segment.find<bip::vector<InData>>("InDataVector").first;
            // Use vector in reverse order
    
            bip::vector<InData>::iterator it;
    
            cv::Mat_<cv::Vec3b> im;
            for(it = myvector->begin(); it !=myvector->end(); ++it){
                im.resize(it->sizeImg);
                memcpy(im.data, &it->image[0], it->sizeImg);
                cv::imshow("window1", im);
            }
    
            segment.destroy<bip::vector<InData>>("InDataVector");
    
            return 0;
        }
        return 0;
    }
    
```
CC BY-SA 3.0
2017-01-19T06:43:34.410
31968
2017-01-21T02:29:10.050
2017-01-20T02:56:07.990
19922
19922
question
c++ boost memory-leaks nullpointerexception
Boost shared memory でのアロケートがうまく行かない？
> While文終了後にエラーになります。(core dump)  
>  このエラーは何を意味しているのか検索しても出てきません。  
>  どういうときに出るエラーなのですか？

プログラムの実行中に回復不可能なエラーが発生し、実行を中止せざるを得ない場合に、デバッグを目的としてメモリ状態一式を保存してからプログラムを終了させます。ここで保存された情報をコアファイルと呼び、保存する行為をコアダンプと呼びます。

ですので、回復不可能なエラーが発生したことしかわからず、どのようなエラーが発生したのかはコアファイルの解析（デバッグ）が必要になります。
CC BY-SA 3.0
2017-01-21T02:29:10.050
32035
2017-01-21T02:29:10.050
4236
31968
answer