Using operator "()" inside boost matrix

Hi,

I've wrote a class inherit from boost matrix, however, I can't figure out how to access the random access operator "()" inside the class.

For instance, I can use "()" outside the class by m.(x, y) = some_value, however, inside the class I can't just using (x, y) = some_value, although my compiler didn't complain this way, some_value will not be assigned successfully.

Neither this(x, y), *this(x, y), this->(x, y) will pass the compiler. (I have to confess that I'm not familiar with the usage of "this"...)

Besides, I can't examine the value of x_location and y_location inside the following for-loop, is it a bug of gdb?

Here is my code, any idea?

Code:

---

#ifndef TARGET_REGION_H
#define TARGET_REGION_H

#include <iostream>
#include <vector>
#include <utility>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

using namespace std ;
using namespace boost::numeric ;

class Target_Region: public ublas::matrix<bool>
{
public:
        Target_Region( const int width, const int height, const vector<int> to_be_inpaint_vec_x, const vector<int> to_be_inpaint_vec_y )
        {
                assert( to_be_inpaint_vec_x.size() == to_be_inpaint_vec_y.size() ) ;

                bool preserve_previous_value = false ;
                resize( width, height, preserve_previous_value ) ;

                // for each pixel location in to_be_inpaint_vec, markup to true in the target region
                vector<int>::const_iterator x_location_iter = to_be_inpaint_vec_x.begin() ;
                vector<int>::const_iterator y_location_iter = to_be_inpaint_vec_y.begin() ;
                int x_location = 0 ;
                int y_location = 0 ;
                for( ; x_location_iter != to_be_inpaint_vec_x.end() ; ++x_location_iter, ++y_location_iter )
                {
                        x_location = *x_location_iter ;
                        y_location = *y_location_iter ;
                        ( x_location, y_location ) = true ;
                }
        }

private:

};


#endif

---

Quote:

---

For instance, I can use "()" outside the class by m.(x, y) = some_value, however, inside the class I can't just using (x, y) = some_value, although my compiler didn't complain this way, some_value will not be assigned successfully.

---

That's because:

Code:

---

( x_location, y_location ) = true ;

---

becomes:

Code:

---

y_location = true ;

---

Quote:

---

Neither this(x, y), *this(x, y), this->(x, y) will pass the compiler. (I have to confess that I'm not familiar with the usage of "this"...)

---

You should use (*this)(x, y) or more explicitly, operator()(x, y).

By the way, are you sure Boost's matrix classes are designed to be base classes? I would expect them to follow the C++ Standard Library convention, and the standard containers are not designed to be base classes.

Hi laserlight,

You're right. Using operator()(x, y), my program now executes as expected.
Thanks a lot.

However, I'm not very sure about why STL containers should not be base classes.

Quote:

---

However, I'm not very sure about why STL containers should not be base classes.

---

Read:
When should my destructor be virtual?
Why are destructors not virtual by default?

Thanks for your information.

So, if my self-defined container hold an "is-a" relationship (I know I can do it by "has-a" relationship, however, that's awkward) with some STL container, and I want the convenience from inheritance and some self-defined functionality, what may be the better approach?

Quote:

---

So, if my self-defined container hold an "is-a" relationship (I know I can do it by "has-a" relationship, however, that's awkward) with some STL container, and I want the convenience from inheritance and some self-defined functionality, what may be the better approach?

---

You can either do the right thing and just use composition ("has-a"), fowarding functions if necessary, or you can ignore the fact that you are deriving from a class that is not designed to be a base class and risk undefined behaviour if someone attempts to use polymorphism through a base class pointer that has delete or delete[] applied to it.