Re: by-const-ref vs. by-value

Hi,
I want to share my observations on the "passing arguments to
functions" mechanism. This is an obvious stuff for some, but may not
be for others, like it was not for me.

   void fun( Type const & val ); // by-const-ref

is not the same (but faster way) as

   void fun( Type val ); // by-val

I do not want to say that the by-const-ref version may ommit the copy,
or that the by-value version can avoid copy in the copy-and-swap idiom
due to copy-elision optimization. I just want to show that the two
mean (or may mean) soething different.

The by-val is closer to the functional programming style, and says we
are interested in the value rather than the object that is passed as
an argument. This means that we guarantee we will not modify the
original. The copy constructor may be invoked or not: it depends on
what optimizations can be performed.

The by-const-ref doesn't give this guarantee:

   void fun( T const& val )
   {
     T& mutable_val = const_cast<T&>(val);
        // did I promise I wouldn't modify val?
   }

If the above example looks too nasty, consider this one (I believe I
have seen it in one of Andrew Koenig's posts):

   typedef std::vector<T>::iterator Iter;

   transform( Iter beg, Iter end, T const& val )
   {
        for( ; beg != end ; ++beg ) {
                *beg += val; // is every element increased by the same value?
        }
   }

   void fun( std::vector<T> & rng )
   {
     Iter pivot = find_pivot_element( rng.begin(), rng.end() );
        transform( rng.begin(), rng.end(), *pivot );
   }

No casting, no "aliasing with global objects", no multi-threading, and
still...
It is not a trick. It is just that by-const-ref means we refer to the
value of some object, which may change during our function's
execution, because it may be also referred to by other non-const
references.