Right shifting of positive integers leads to truncation:
9 >> 149 >> 22
-9 >> 1-5-9 >> 2-3
-(-9 >> 1)5-(-9 >> 2)3
int rightShiftRoundUp(int x, int n){return - ( -x >> n);}
Note: This is just a rewrite of The Safe Bool Idiom by Bjorn Karlsson in my own words.
How do you provide for boolean tests for your classes in C++?
It is trivial for raw pointers:
if (T* p = get_some_value()){
// p is valid and not null we can use it here
}
else{
// p is null/invalid.
}Any rvalue of arithmetic, enumeration, pointer, or pointer to member type, can be implicitly converted to an rvalue of type bool.
TPtr p(get_some_value());You might have a member function for testing in boolean contexts:
if(p.is_valid()){
// p is valid, use it
}
else{
// p is not valid. Take proper action.
}Cons
Objective
May be you would code something like this:
class Testable {
bool ok_;
public:
explicit Testable(bool b=true):ok_(b) {}
operator bool() const {
return ok_;
}
};We can use like following:
Testable test;
if (test)
std::cout << "Yes, test is working!\n";
else
std::cout << "No, test is not working!\n";
Bravo!
But what about:
test << 1;
int i=test;
Take more side effects:
Testable a;
AnotherTestable b;
if (a==b) {
}
if (a<b) {
}
A possible enhancement here:
class Testable {
bool ok_;
private int () const ;
public:
explicit Testable(bool b=true):ok_(b) {}
operator bool() const {
return ok_;
}
};Remember the old C trick?
int x = !! y; // maps y to 0 or 1.
We can do something like this in C++:
class Testable {
bool ok_;
public:
explicit Testable(bool b=true):ok_(b) {}
bool operator!() const {
return !ok_;
}
};Now we can write:
Testable test;
if (!!test)
std::cout << "Yes, test is working!\n";
if (!test2) {
std::cout << "No, test2 is not working!\n";
Pros:
Cons:
We can off course write a conversion function to void*:
class Testable {
bool ok_;
public:
explicit Testable(bool b=true):ok_(b) {}
operator void*() const {
return ok_==true ? this : 0;
}
};This can be safely used in if(test).
But what about following?
Testable test;
delete test;
Courtesy Don Box 1996, C++ Report:
class Testable {
bool ok_;
public:
explicit Testable(bool b=true):ok_(b) {}
class nested_class;
operator const nested_class*() const {
return ok_ ? reinterpret_cast<const nested_class*>(this) : 0;
}
};Pros
Cons:
Testable b1,b2;
if (b1==b2) {
}
if (b1<b2) {
}
Lets declare an unspecified nested function type:
class Testable {
bool ok_;
typedef void (Testable::*bool_type)() const;
void this_type_does_not_support_comparisons() const {}
public:
explicit Testable(bool b=true):ok_(b) {}
operator bool_type() const {
return ok_==true ?
&Testable::this_type_does_not_support_comparisons : 0;
}
};The above code still allows following:
Testable test;
Testable test2;
if (test1==test2) {}
if (test!=test2) {}
Lets close the loop as follows:
template <typename T>
bool operator!=(const Testable& lhs,const T& rhs) {
lhs.this_type_does_not_support_comparisons();
return false;
}
template <typename T>
bool operator==(const Testable& lhs,const T& rhs) {
lhs.this_type_does_not_support_comparisons();
return false;
}
So you designed your own powerful and scalable and efficient version of malloc and named it my_malloc. Now you wish to make sure that everybody in your team uses this version of malloc rather than calling the standard C library version. How would you enforce that?
#undef malloc#define malloc use_my_malloc_please
You just put the above code in a common header file for your project which gets included everywhere. Anybody who tries to use standard library malloc, will get a compilation error. Hmm, this is only if you are a C style programmer. In C++ off course you can override new and delete operators for a class as well as introduce your own new handlers.
1: # define offsetof(T, F) ((unsigned int)((char *)&((T *)0)->F))
1: unsigned char clamp(short value){2: if (value < 0) return 0;3: if (value > 0xff) return 0xff;4: return value;5: }
1: const unsigned char clamp(int a)2: {3: if (a&(~0xFF)) return (-a)>>31;4: else return a;5: }
1: template void swap(T& a, T& b){2: T tmp;3: tmp = a;4: a = b;5: b = a;6: }
1: #define FFSWAP(T,a,b) do{T SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
int square (int) __attribute__ ((pure));
