Mix concrete and non-concrete types in templates C++

Question

My problem is somewhat like partial specification in a template class C++.

I write a template<class T> class matrix to carry some matrix computation. For this class I define overloaded comparison operators such as ==, >=, <=. I want this snippet of code

matrix<float> a(2,3), b(2,3);
a.fill(1); b.fill(2);
matrix<bool> c = (a == b);

results in a boolean matrix c having the same size of a and b and that c(i,j)<-true iff a(i,j) == b(i,j) . With the following code this could not be done

template<class T>
class matrix
{
public:
    matrix ();
    matrix (size_t rows, size_t cols);
    matrix (const matrix<T>& mx);

    size_t rows() const;
    size_t cols() const;
    size_t size() const;

    const T* ptr() const;
    T* mutable_ptr();

    // etc
private:
    size_t num_rows;
    size_t num_cols;
    vector<T> data;
}

template<class T> const T* matrix<T>::ptr() const { return data.data(); }
template<class T> T* matrix<T>::mutable_ptr() { return data.data(); } // line **459**

template<class T> matrix<bool>&  operator< (const matrix<T>& mx, const T t);
template<class T> matrix<bool>&  operator<= (const matrix<T>& mx, const T t);
template<class T> matrix<bool>&  operator> (const matrix<T>& mx, const T t);
template<class T> matrix<bool>&  operator>= (const matrix<T>& mx, const T t);
template<class T> matrix<bool>&  operator== (const matrix<T>& mx, const T t);
template<class T> matrix<bool>&  operator!= (const matrix<T>& mx, const T t);
// ...
template<class T> matrix<bool>&  operator== (const matrix<T>& mx, const T value) { // line **547**
    matrix<bool> *index = new matrix<bool>(mx.rows(), mx.cols());
    const T *ptr = mx.ptr();
    bool *ptr_i = index->mutable_ptr();
    size_t m = mx.size();
    for (size_t i=0; i < m; ++i) {
        if (ptr[i] == value)
            ptr_i[i] = true;
        else
            ptr_i[i] = false;
    }
    return *index;
}

The compiler outputs

matrix.hpp: In member function ‘T* matrix<T>::mutable_ptr() [with T = bool]’:
matrix.hpp:547:35:   instantiated from ‘matrix<bool>& operator==(const matrix<T>&, T) [with T = float]’
compute_sil.cpp:163:26:   instantiated from here
matrix.hpp:459:66: error: void value not ignored as it ought to be

Is there any way to overcome this?

EDIT Sorry to put not enough codes, I did overload of operators with many argument types, between a matrix vs. scalar, and between matrices too.

template<class T> matrix<bool>&  operator< (const matrix<T>& mx, const matrix<T>& mx2);
template<class T> matrix<bool>&  operator<= (const matrix<T>& mx, const matrix<T>& mx2);
template<class T> matrix<bool>&  operator> (const matrix<T>& mx, const matrix<T>& mx2);
template<class T> matrix<bool>&  operator>= (const matrix<T>& mx, const matrix<T>& mx2);
template<class T> matrix<bool>&  operator== (const matrix<T>& mx, const matrix<T>& mx2);
template<class T> matrix<bool>&  operator!= (const matrix<T>& mx, const matrix<T>& mx2);

template<class T> matrix<bool>&  operator< (const T t, const matrix<T>& mx);
template<class T> matrix<bool>&  operator<= (const T t, const matrix<T>& mx);
template<class T> matrix<bool>&  operator> (const T t, const matrix<T>& mx);
template<class T> matrix<bool>&  operator>= (const T t, const matrix<T>& mx);
template<class T> matrix<bool>&  operator== (const T t, const matrix<T>& mx);
template<class T> matrix<bool>&  operator!= (const T t, const matrix<T>& mx);

Unrelated to your problem, but you have a memory leak in your equality operator. — Some programmer dude, Nov 20 '15 at 13:58
@pateheo You have `const T` as the second parameter, not `const matrix&`. Decide which one you want. — LogicStuff, Nov 20 '15 at 14:01
Oh, and that example you show, with comparing two `matrix` objects, that won't call the equality operator you show us (or give the error you show). — Some programmer dude, Nov 20 '15 at 14:02
There are some missing pieces of information here, but I have the bad feeling that somewhere along the way, you compare floating-point numbers with `==`. If so, search Google for something like "floating-point numbers equality". — Christian Hackl, Nov 20 '15 at 14:05
Perhaps a better - than what I suggested initially - duplicate would be this: http://stackoverflow.com/q/16568986/2079303 — eerorika, Nov 20 '15 at 14:07
If you recreate your code on an online compiler like [this one](http://coliru.stacked-crooked.com/) it would make it a lot easer to find your bug. Your example code is missing the code for fill(). — rozina, Nov 20 '15 at 14:13
@user2079303 thank you! You spot the right problem. Now I could fix it. — pateheo, Nov 20 '15 at 14:24
@JoachimPileborg you mean my code lacks of a destructor, or the temporary object created by `(a == b)` is leaked? — pateheo, Nov 20 '15 at 14:44
Yes, you allocate a new object using `new`, but you don't `delete` it anywhere. Don't allocate it dynamically. — Some programmer dude, Nov 20 '15 at 14:45

score 0 · Answer 1 · answered Nov 20 '15 at 14:27

As commented by @user2079303, the problem is due to my use of std::vector<bool>, not related to template c++. vector<bool> does not provide a pointer to its data. I change from using bool to char or int so that my program is nicely compiled. Thank you @user2079303.

Mix concrete and non-concrete types in templates C++

1 Answers1