B>Вообще-то я пытался так пошутить

class myPoint
{
     int m_x;
     int m_y;
     int m_z;

public:
     myPoint()
     {
          this->m_x = -1;
          this->m_y = -1;
          this->m_z = -1;
     }

     bool operator == (int a)
     {
          return m_x == a && m_y == a && m_z == a;
     }
};

myPoint a[3][3][3] = { ... };
if (a[i][j][k])
{
     ...
}

SM>myPoint a[3][3][3] = { ... };
SM>if (a[i][j][k])
SM>{
SM>     ...
SM>}
SM>

class myPoint
{
     int m_x;
     int m_y;
     int m_z;

     void safe_bool_fn() const;
     typedef void (myPoint::*safe_bool)() const;
public:
     myPoint()
     {
          this->m_x = -1;
          this->m_y = -1;
          this->m_z = -1;
     }

     bool operator == (int a)
     {
          return m_x == a && m_y == a && m_z == a;
     }

     operator safe_bool () const { return (-1 == m_x && -1 == m_y && -1 == m_z) ? 0 : &myPoint::safe_bool_fn; }};

int main()
{
   myPoint a[3][3][3] = { };
   if (a[0][0][0])
      return 1;

   return 0;
}

E>А зачем таки сложности, для такой простой задачи?

чтобы уж быть правильным до конца

Данный вариант меня устраивает. Но хотелось реализовать скажем такую конструкцию:

myPoint a[3][3][3] = { ... };
if (a[i][j][k])
{
     ...
}

SM>class myPoint
SM>{
SM>     int m_x;
SM>     int m_y;
SM>     int m_z;

SM>public:
SM>     myPoint()
SM>     {
          this->>m_x = -1;
          this->>m_y = -1;
          this->>m_z = -1;
SM>     }

SM>     bool operator == (int a)
SM>     {
SM>          return m_x == a && m_y == a && m_z == a;
SM>     }
SM>};
SM>

class mypoint
{
    .....
public:
    bool isNothing() const // не забываем про константность!
    {
        return m_x==-1 && m_y==-1 && m_z==-1;
    }
    
    operator safe_bool() const { return to_safe_bool(!isNothing()); }
};

class mypoint
{
    int m_x, m_y, m_z;
    bool m_initialized;
public:
    mypoint() : m_initialized(false) {}
    mypoint(int x, int y, int z) : m_x(x), m_y(y), m_z(z), m_initialized(true) {}
    .....
};

class mypoint
{
public:
    mypoint() {} // забивает на инициализацию
    mypoint(int x, int y, int z);
    .....

    friend operator ==(mypoint const& a, mypoint const& b) { return a.m_x==b.m_x && a.m_y==b.m_y && a.m_z==b.m_z; }
    friend operator !=(mypoint const& a, mypoint const& b) { return !(a==b); }
};

template<int X0, int Y0, int Z0>
class mypoint_z : public mypoint
{
public:
    mypoint_z() : mypoint(X0,Y0,Z0) {}
    mypoint_z(int x, int y, int z) : mypoint(x,y,z) {}
    
    operator safe_bool() const { return to_safe_bool( *this != mypoint_z() ); }
};

К>template<int X0, int Y0, int Z0>
К>class mypoint_z : public mypoint