Question

there are probably several ways I will expose my ignorance with this question 🙂

First, I think this is C++ code, but the extension of the file is .C (so maybe it is C?)

Anyway, I am trying to compile a program called Sundance (Sentence UNDerstanding ANd Concept Extraction) which is a Natural Language Processing tool. The compile error I get relates to the following:

// This class is used internally to keep track of constituents that are
// potential subjects for clauses during clause handling.
class PotentialXP {
public:
  Constituent* XPPtr;
  unsigned int Distance;
  unsigned int ClauseIndex;
  unsigned int ConstIndex;

  PotentialXP() {
    XPPtr         = 0;
    Distance      = 0;
    ClauseIndex   = 0;
    ConstIndex    = 0;
  };

  operator int() const {
    return (int)XPPtr;  
  };

  void Set(Constituent* w,
           unsigned int x,
           unsigned int y,
       unsigned int z){
    XPPtr         = w;
    Distance      = x;
    ClauseIndex   = y;
    ConstIndex    = z;
  };
};

The error is “cast from ‘Constituent* const*’ to ‘int’ loses precision”

and relates to the lines:

operator int() const {
  return (int)XPPtr;    
};

I understand why I get an error. XPPtr is of type Constituent*, so how can it be converted to an integer? Can anyone figure out what the author of the code wants to do here, and how I might rewrite this line so it compliles? What is an operator function (if that’s what you call it) for?

Any advice much appreciated!

Answer 1

That compiles fine for me. You are on a 64-bit machine, where size_t is larger than int.

Explanation: you can historically convert a pointer an int

struct Foo {};

int main ()
{
    Foo * f = new Foo ();
    std :: cout << (int)f; // Prints 43252435 or whatever
}

If you want an integer which is the same size as a pointer, use size_t or ssize_t.

And why on earth are you writing operator int() like that anyway? Do you want operator bool() to test for validity? In which case a function body of return NULL != XPPtr would be better style — clearer, at least.