जब मैं एक [=] कैप्चर (लैम्ब्डा कक्षा का उपयोग कर) का उपयोग करता हूं तो एक चर 'कॉन्स्ट' क्यों बनता है?

Question

Premise # 1: मैंने पहले से ही त्रुटि हल कर दी है, लेकिन मैंने संकलक त्रुटि के कारण को गहराई से समझ नहीं लिया।

Premise # 2: इस कार्यक्रम का लक्ष्य एक छवि को एक बहुप्रचारित प्रक्रिया द्वारा किसी अन्य छवि में कॉपी करना है। शायद एक बेहतर तरीका मौजूद है, लेकिन यह प्रश्न का फोकस विषय नहीं है (आधार # 1 देखें)।

मैंने एक छवि को दूसरी छवि में कॉपी करने के लिए ओपनसीवी 3.1 लाइब्रेरी का उपयोग करके एक सरल प्रोग्राम लिखा था। यह अधिक धागे का उपयोग कर सीपीयू के सभी कोर का लाभ उठाता है।

कोड है:

#include <opencv2/opencv.hpp> 
#include <iostream> 
#include <stdio.h> 
#include <stdlib.h> 
#include <thread> 

using namespace cv; 
using namespace std; 

#define IMG_PATH "..\\img\\50a.png" 


void copy_image(const Mat& input, Mat& output, int row_offset, int skip_row) 
{ 
    cout << row_offset; 
    Size size = input.size(); 
    for (int r = row_offset; r < size.height; r += skip_row) 
    { 
     for (int c = 0; c < size.width; c++) 
     { 
      output.at<Vec3b>(r, c) = input.at<Vec3b>(r, c); 
     } 
    } 
} 

int main() 
{ 
    Mat input_img = imread(IMG_PATH); 
    Mat output_img = Mat(input_img.size(), input_img.type()); output_img.setTo(255); 

    vector<thread> threads; 
    int thread_number = thread::hardware_concurrency(); 

    for (int i = 0; i < thread_number; i++) 
    { 
     cout << i; 
     auto var = [=]() 
     { 
      return copy_image(input_img, output_img, i, thread_number); 
     }; 

     threads.push_back(thread(var)); 
    } 

    for (auto& thread : threads) 
     thread.join(); 

    imshow("output_img", output_img); 
    imwrite("result.png", output_img); 
    waitKey(0); 
} 

संकलक मुझे इस त्रुटि देता है

त्रुटि C2664 'शून्य copy_image (स्थिरांक सीवी :: चटाई &, सीवी :: चटाई &, पूर्णांक, पूर्णांक) ': से तर्क 2 परिवर्तित नहीं कर सकते' सीवी 'को' स्थिरांक सीवी :: चटाई :: चटाई & '

return copy_image(input_img, output_img, i, thread_number); 

मैं इस

auto var = [=, &input_img, &output_img]() 

के साथ इस लाइन

auto var = [=]() 

की जगह इस त्रुटि को हल किया, लेकिन वास्तव में मैं गहराई से समझ में नहीं आता क्यों मुझे लगता है कि प्राप्त किया: यह कोड की इस पंक्ति reffers कि त्रुटि।

Answer 1

आप मूल्य से एक पर कब्जा करते हैं में एक लैम्ब्डा, आपको एक 'सदस्य' मिलेगा जो संग्रहीत हो जाता है। डिफ़ॉल्ट operator() एक कॉन्स्ट फ़ंक्शन है, इसलिए आप उन्हें संशोधित नहीं कर सकते हैं।

स्थानीय चर को संशोधित करने के लिए लैम्ब्डा को []() mutable {} के रूप में परिभाषित किया जा सकता है।

संदर्भ द्वारा मूल्य को कैप्चर करके, आपके पास कुछ ऐसा है जो एक गैर-कॉन्स्ट ऑब्जेक्ट के लिए कॉन्स्ट पॉइंटर की तरह व्यवहार करता है, इसलिए उत्परिवर्तनीय के बिना, आप उन वस्तुओं को अनुकूलित कर सकते हैं। (जब तक वे पहले से ही कहाँ नहीं हैं)

Answer 2

कब्जा कर लिया चर लांबा के दायरे में वास्तव में const हैं:

[foo]() 
{ 
    // foo, whatever that is, is const 
} 

एक परिवर्तनशील लैम्ब्डा में, पर कब्जा कर लिया चर स्थिर नहीं कर रहे हैं:

[foo]() 
mutable { 

    // Lambda can modify foo, but it's a copy of the original 
    // captured variable 
}