david@cs.washington.edu (David Callahan) (02/16/90)
Suppose that you had a parallel program with a shared object (like ostream cout) such that you wanted certain expressions to be performed atomically. For example, you wanted the line cout << file << ":" << line << ":" << msg << "\n"; to be continguous but you don't care its relative position with regard to similar messages A scheme I came up with was to differentiate the first operator from the last in the type system and then catch the final expression as a cast to void. Here was the test program. "foo" plays the role of ostream and "foo1" is introduced to handle "interior" operators. -------------------------------------------------- class foo1 { protected: void lock() ; void unlock() ; public: operator void() ; struct foo1 & operator << (int) ; } ; struct foo : public foo1 { foo1 & operator << (int i) ; } ; main () { foo f ; int i ; f << i << i ; void(f << i << i) ; (void) (f << i << i) ; } foo1 & foo::operator << (int i) { lock() ; return foo1::operator<<(i) ; } foo1::operator void() { unlock() ; } -------------------------------------------------- I had hoped that the line f << i << i ; would be implemented as: foo1::void( foo1::operaotr<< (foo::operator<<(&f,i) i)) but alas g++ (gcc version 1.36.1 (based on GCC 1.36)) would not make the call to operator void, even when the cast to void was made explicit as on the last two lines. Is defining operator void legal? (g++ gave no messages) If so, it seems that g++ is in error when the explicit cast is present. Should implicit casts to void also invoke the operator void? I certainly hope so since explicit casts to void seem very uncommon. -- David Callahan (david@tera.com, david@june.cs.washington.edu,david@rice.edu) Tera Computer Co. 400 North 34th Street Seattle WA, 98103