genneth's New Writeups

conditional operator (idea)

2005-03-11T09:07:20Z

There is something which has been ignored by all the WU's so far -- the type of the expression. In C++ all expressions are statically typed, so the compiler must know what all the types of the expressions are. For the simple <grin> case, the following rules are obeyed for ( T ? A : B ):

If A and B are of the same type, then the entire expression has that type.
If A can be converted to B, it does so.
Then the other way is considered.

This is the simple case because we have ignored l/r-values, and const/volatile cases. It happens that there are some more conditions for those cases. Language lawyers may refer to The Good Book for more details.

Why is this important? Because it allows us to get the type of an expression without having to evaluate it. Suppose we have the following functions:

template <typename T>
std::string get_type_name(T x) {return "unknown";}

…

concept (idea)

2005-02-22T18:25:51Z

In C++, Concepts were first (?) introduced by STL. Unlike most of C++, they are not compiler enforced. Rather, they are documents that specify the structure needed by objects to work with templated algorithms/frameworks. Concepts may be fulfilled by Models, which are just types (including builtin types such as int). For example, the STL specifies the Concept of Sequence, which is a refinement (think subclass) of Container. Sequence may be modelled by vector, list, tree, etc. As long as a type fulfills certain requirements, such as having begin and end methods that behave in a certain way, it may be considered to Model a Concept. There is no explicit statement of relationship. Concepts are usually used within template frameworks, as a way of restricting what may be put as template parameters.

The crucial bit is that Concepts are NOT checked by the compiler. Indeed, the compiler has no clue about Concepts. They only exist in your head. There…

Curiously Recurring Template Pattern (idea)

2005-02-22T14:40:44Z

This is a C++ idiom, perhaps best expressed by the following:

template <typename T> class Base;
class Derived: public Base<Derived> {
    // stuff

This allows Base to reach into Derived's namespace and use methods without the overhead of virtual dispatch. This also allows recursive data types to be defined.

Examples:

template <typename T>
class easy_comparisons {
public:
    bool operator>(const T & rhs) {
        return rhs < *(static_cast<T *>this); // uses operator < in T's namespace
    }

    bool operator==(const T & rhs) {
        return !(*(static_cast<T *>this) < rhs) && !(rhs < *(static_cast<T *>this));
    }
    // other overloads for <=, >=, != ...
};

class some_numeric : public easy_comparisons<some_numeric> {
public:
    bool operator<(const some_numeric & rhs) {
        // something...
    }
};

…

do { ... } while(0) (idea)

2005-02-22T09:39:57Z

Actually, this can be used in another case, to test for errors:

do {
    if(!test1()) break;
    if(!test2()) break;
    if(!test3()) break;
    /* actual code */
} while(0);

This is pretty useless in C, since this sort of thing is much better handled by goto (yes, yes, I know, but even the Linux kernel does it). And higher level languages can use exceptions. But in PHP, before version 5, this was the best way to do error testing and defensive programming.

C++: true or false? (idea)

2005-02-22T09:08:03Z

First, a disclaimer, this is something that I have learnt from other sources -- I can't remember where, except for the fact that I'd taken the source from the examples that it gave and used them in my own code. Please msg me about any formatting inconsistencies -- things like < and & need to be escaped to be valid HTML, and I may not have got all of them.

Ah Ariels -- if only it was that easy. Conversion to bool, as you have noted, is bad because we can do arithmetic on it. Which is not cool. But conversion to void * allows two things that we don't want:

Testable_By_Conversion t;
delete t; // damn! that sucks!
std::cout << t;

Yep, that's right, we can delete it, and we've got a surprise when the compiler implicitly converts it. The second one can be extended to any time when a void * can be used, which, if it happens deep in a template library, can be really hard to pick apart.

…

Nonlocal conservation laws (idea)

2003-10-10T14:30:22Z

Most of physics becomes easier as soon as you realise that some things are always the same: energy, mass, charge, etc. Thus we tend to think of these quantities as flowing from one place to another, i.e. if it disappears from here in this instant, it will be somewhere very closeby in the next instant. However, a brief thought experiment will reveal otherwise. Consider two masses suspended over a pulley in a gravitational field -- then a change of position (and potential energy) in one will be transferred (potentially) to somewhere entirely different.

But how local is local? Special relativity can be interpreted to say that nothing, including information, can travel faster than the speed of light. So in the experiment above, the effect is still local -- the speed at which the propagation of a mechanical wave through whatever medium the two masses were joined is still less than the speed of light. We could say that the "string" took up our slack.

So really, in our current context,…