Thread: 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

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 ;

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.

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?

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.