Re: reference and pointer-reference

kasthurirangan.balaji@gmail.com wrote:


Be careful here. Passing by const reference (as in your example) is an
optimization when you are dealing with an object that allocates memory
or who's size is larger than sizeof( int ), but only if you don't end up
copying the object inside the function anyway. The function declaration
you came across, "reference to pointer to char" is not such a beast.
Removing the 'const' qualifier makes it completely different.

A non-const reference parameter is used create an "in/out" parameter. In
other words, you can use that parameter to pass data into the function,
and it can use the parameter to pass data back out to the calling code.

Generally, non-const reference parameters are used as an optimization
when the return value allocates memory or is larger than sizeof int (to
avoid the copy... compilers can often do this particular optimization on
their own though so it isn't that common,) or when a function needs to
return multiple chunks of data.

Let's say for example that you have a char* that contains a bunch fields
separated by tabs (assume that other whitespace characters could be
embedded in these fields,) and you want to break these fields up into a
bunch of strings... How do you write a function that extracts each
field, then returns both the string extracted and the position of the
next field?

Here are some ideas to solve that problem:

string idea1( const char* in ) {
   string result;
   while ( *in && *in != '\t' )
      result.push_back( *in );
   return result;
}

The above function extracts the field, but the calling function must
advance the input on its own, like this maybe:

   vector<string> fields;
   while ( *data ) {
      fields.push_back( idea1( data ) );
      data += fields.back().size() + 1;
   }

However, if we make the parameter an in/out one, then we can do this:

string idea2( const char*& inOut ) {
   string result;
   while ( *inOut && *inOut != '\t' )
      result.push_back( *inOut++ );
   ++inOut;
   return result;
}

Now the caller need not take care of pointer advancement on its own:

   vector<string> fields
   while ( *data ) {
      fields.push_back( idea2( data ) ); // data is modified by the call
   }

Of course, in returning the string, note that the function has to build
the string, then create a temporary copy of it to pass to the caller.
Often the compiler can optimize the copy away (look up return value
optimization (RVO)). However, if profiling shows this to be a
bottleneck, we can use:

void idea3( const char*& inOut, string& result ) {
   result = string();
   while ( *inOut && *inOut != '\t' )
      result.push_back( *inOut++ );
   ++inOut;
}

which would be used like so:

   vector<string> fields;
   while ( *data ) {
      string str;
      idea3( data, str );
      fields.push_back( str );
   }