为类对象指定“返回类型”

Question

I have the following class, which is supposed to represent an 8 bit signed char.

class S8
{
private:
    signed char val;
public:
    S8 & operator=(const signed char other)
    {
        if ((void*)this != (void*)&other)
        {
            val = other;
        }
        return *this;
    }
    operator signed char() {signed char i; i = (signed char) val; return i;}
    void write (OutputArray & w)
    {
        /* This function is the whole purpose of this class, but not this question */
    }
};

However, when I assign a negative number to one of its objects,

S8 s;
char c;

s = -4;
c = -4;

printf("Results: %d, %s\n",s,c);

I get "Results: 252, -4" from the printf. Is there any way to modify the class such that cases like this will see the behaviour of a signed char, rather than the unsigned char behaviour I am getting?

Thanks!

Answer 1

What you want is an implicit conversion from a signed char to an S8 object; and this is accomplished with a non-default copy-constructor. If a copy-constructor taking a signed char is defined, then compilers will use this for implicit conversions (assuming the copy-constructor is not defined as "explicit"). So, for your example:

class S8
{
private:
    signed char val;
public:
    //default constructor
    S8() : val(0) {}

    //default copy-constructor
    S8(const S8& rhs) : val(rhs.val) {}

    //allow implicit conversions (non-default copy constructor)
    S8(const signed char rhs) : val(rhs) {}

    //allow implicit conversions
    operator signed char() { return val; }
};    

int main()
{
  S8 s;
  signed char c;

  s = -4;
  c = -4;

  std::cout << (int) s << std::endl;
  std::cout << (int) c << std::endl;

  return 0;
}

Answer 2

Your code makes no sense at all, while the behavior you experience is completely arbitrary as printf must not be used that way. (did you at least turn on warnings in your compiler? Many would flag your error!)

Besides that, your in and out converters did what you were after, just phrased badly. In op= the rhs is char, it can not possibly be on the same address of your class so you can just go ahead and storing it.

The implicit conversion op also needs no fuss just return the member.

Why you need this is unclear, possibly you should read up on implicit conversions and custom op= stuff. As it holds all kinds of danger, and should only be used by those clearly know when the conversions will apply, that the client code is such to welcome that, and the client code is unlikely to fall in a pit with the conversion present.