C++ custom iterator and (*this) - c++

Question

I am definining a custom iterator
class row_iterator {
// To iterate over nodes.
friend class Hamiltonian;
public:
typedef row_iterator self_type;
typedef int value_type;
typedef std::forward_iterator_tag iterator_category;
row_iterator( const Bipartite & B ) : _B( other._B ) , _i( 0 ) {}
row_iterator( const Bipartite & B , const int i ) : _B( other._B ) , _i( i ) {}
row_iterator( const self_type & other ) : _B( other._B ) , _i( other._i ) {}
self_type operator=( const self_type & other ) { _B = other._B; _i = other._i; return ( * this ); }
self_type operator++() { _i++; return ( * this ); } // PREFIX
self_type operator++( int junk ) { self_type tmp = ( * this ); _i++; return tmp; } // POSTFIX
value_type & operator*() { return _i; }
//value_type * operator->() { return & _i; }
bool operator==( const self_type & rhs ) { return ( _i == rhs._i ) and ( _B == rhs._B ); }
bool operator!=( const self_type & rhs ) { return ( _i != rhs._i ) or ( _B != rhs._B ); }
operator bool() { return _i < _B.num_rows(); }
void test_func() {
int i = ( * this );
bool b = ( * this );
}
private:
Bipartite & _B;
int _i;
};
Pay attention to the function test_func(). Now the question...
If I write
int i = ( * this );
I assume that int operator*() is called. On the other hand, if I write
bool b = ( * this );
I assume that operator bool() is called. Is this the case?
EDIT: Here I add the test that checks that the voted answer is correct.
#include <iostream>
class iter {
public:
typedef iter self_type;
typedef int value_type;
typedef std::forward_iterator_tag iterator_category;
iter( int imax ) : _i( 0 ) , _imax( imax ) {}
value_type operator*() { return _i; }
self_type operator++() { _i++; return ( * this ); } // PREFIX
self_type operator++( int junk ) { self_type tmp = ( * this ); ++( * this ); return tmp; } // POSTFIX
operator bool() { return _i < _imax; }
void test() {
bool b = ( * this );
int q = ( * this );
int i = ( * ( * this ) );
std::cout << "b = " << b << " , q = " << q << " , i = " << i << std::endl;
}
private:
int _i;
int _imax;
};
int main( void ) {
iter it( 10 );
while ( ( bool ) it ) {
it.test();
it++;
}
}
The output, reads:
b = 1 , q = 1 , i = 0
b = 1 , q = 1 , i = 1
b = 1 , q = 1 , i = 2
b = 1 , q = 1 , i = 3
b = 1 , q = 1 , i = 4
b = 1 , q = 1 , i = 5
b = 1 , q = 1 , i = 6
b = 1 , q = 1 , i = 7
b = 1 , q = 1 , i = 8
b = 1 , q = 1 , i = 9

Answer 1

Your second assumption is correct. Your first is not.
You must keep in mind that the type of this is row_iterator*, thus, the result type of *this is row_iterator, which, due to the existence of your operator bool() can be contextually converted to bool which is what happens in your second assignment (bool b = *this).
In your first assignment (int i = (*this)) there is no suitable conversion from row_iterator to int. There is, however, a conversion to bool and converting a bool to an int is possible too, so in its current state, your first assignment will result in i being 1 if operator bool() returns true and 0 otherwise.
In order to fix this, you need to dereference this twice.
To elaborate, implicit conversion (which is what's happening here) consists of up to three conversions:
zero or one standard conversion sequence
zero or one user-defined conversion
zero or one standard conversion sequence.
Standard conversion sequences consist of:
zero or one lvalue transformation
zero or one numeric promotion or conversion
zero or one function pointer conversion (c++17 and up )
zero or one qualification adjustment
Since the standard conversion sequence does not allow pointers to be dereferenced, the only way dereferencing can occur during implicit conversion is if it is done in a user-defined conversion function.