来自&#39;const std :: vector的无效转换 <cv::Mat> *&#39;到&#39;std :: vector <cv::Mat> *&#39;在c ++ 14中

Question

When running the following code

RM_Analyzer.h:

struct FFeatureCalculationImages
{
    std::vector<cv::Mat>* cf_mat;
    std::vector<cv::Mat>* front_mat;
    std::vector<cv::Mat>* back_mat;
};

class RM_Analyzer
{
private: 
DLL_Mat<std::vector<cv::Mat> > sliding_window_frames;
void setImagesForExtendedFeatureCalculation(FFeatureCalculationImages &imgs) const;
}

RM_Analyzer.cpp

void RM_Analyzer::setImagesForExtendedFeatureCalculation(FFeatureCalculationImages &imgs) const
{
    imgs.cf_mat=sliding_window_frames[sliding_window_frames.size()-1-k];
    imgs.front_mat=sliding_window_frames.getFrontMat();
    imgs.back_mat=sliding_window_frames.getBackMat();
}

DLL_Mat.h

template<class T>
class DLLNode
{
public:
    DLLNode<T>* next;
    DLLNode<T>* previous;
    T im;
};


template<class T>
class DLL_Mat
{
private:
    unsigned count;
    DLLNode<T>* front;
    DLLNode<T>* back;

public:
    T* getFrontMat() const;
    T* getBackMat() const;
    unsigned size() const;
    T* operator[](const std::size_t idx);
    const T* operator[](const std::size_t idx) const;
};

template <class T>
inline unsigned DLL_Mat<T>::size() const
{
    return count;
}

template <class T>
T* DLL_Mat<T>::operator[](const std::size_t idx)
{
    if (idx==0)
        return getFrontMat();
    else if (idx==(count-1))
        return getBackMat();
    else if (idx>=size())
        return nullptr;
    else
    {
        std::size_t i=0;
        for (DLLNode<T> *iter=front;i<count;i++,iter=iter->next)
        {
            if (i==idx)
                return &(iter->im);
        }
    }

    return nullptr;
}

template <class T>
const T* DLL_Mat<T>::operator[](const std::size_t idx) const
{
    if (idx==0)
        return getFrontMat();
    else if (idx==(count-1))
        return getBackMat();
    else if (idx>=size())
        return nullptr;
    else
    {
        std::size_t i=0;
        for (DLLNode<T> *iter=front;i<count;i++,iter=iter->next)
        {
            if (i==idx)
                return &(iter->im);
        }
    }

    return nullptr;
}

I have included the operator [] source code for convenience, although the function declarations in DLL_Mat.h and the RM_Analyzer source code are probably enough to find the culprit of the problem.

The compiler seems to be calling a const version of the operator [], which in turn causes a conversion error. The error is (Line 3 in RM_Analyzer.cpp):

error: invalid conversion from ‘const std::vector<cv::Mat>*’ to ‘std::vector<cv::Mat>*’ [-fpermissive]
     imgs.cf_mat=sliding_window_frames[sliding_window_frames.size()-1-k];

My explanation:
1) I seem to have made a logical error somewhere since the function setImagesForExtendedFeatureCalculation should obviously be const since I do not change any internal variable in that method
2) The compiler cannot call non-const operator [] since I declared the method setImagesForExtendedFeatureCalculation as const so sliding_window_frames is treated as const as well
3) I cannot call the const version of the operator [] since the argument (FFeatureCalculationImages) parameters are not declared const (specifically cf_mat, front_mat, back_mat).

This seems to put me in a peculiar position where neither of the operator [] methods is a good fit, yet declaring a T* operator[] (const size_t idx) const; is not a possible overload given the two existing methods in DLL_Mat.h.

Any advice on how to evade the invalid conversion error without throwing away the const function declarations? (since I think that would be a bit sloppy to not declare a function as const just because it is convenient for me)

Answer 1

In sliding_window_frames[sliding_window_frames.size()-1-k] , the compiler does call the const version of operator[] . Which returns a pointer to const std::vector<cv::Mat> . But then you are trying to assign that pointer to imgs.cf_mat , which is a pointer to non-const std::vector<cv::Mat> . This violates const correctness, and so the compiler rightfully complains.

You have a function that can be called on a const instance of the object, trying to hand out mutable pointers to internals of that object. Either that function shouldn't have been declared const , or it should be handing out const pointers, or the internals it exposes should be marked mutable .

Answer 2

Both operator[] methods have same signature (return type is not part of signature; edit: they have different signature because of constness of this pointer) therefore you can't select which method you want to call. Having two identical methods doing same thing but one is returning const value isn't right solution: You can always cast to const but you cant otherway, therefore you should remove method returning const value.

Edit: Field of const object have also const modifier, so operator[] with const this pointer are called (which return const pointer).

PS Operator[] takes const argument in header but non-const argument in definition; size() should return std::size_t.