A little help reducing the opportunity for errors.
If there's two things I drill into the heads of those that work with me, its a couple of the Pragmatic Programmer rules: do not violate the principle of least astonishment, and don't repeat yourself (DRY).

Unfortunately, C++ constructors challenged the second one:

  class SampleBuffer
  {
    public:
      SampleBuffer(int alen) ;
      SampleBuffer(char const * astring) ;

    protected:
      std::unique_ptr    m_buffer ;
      int m_len ;
  } ;

  SampleBuffer::SampleBuffer(int alen) : m_len(alen)
  {
    * m_buffer = new char[alen +1] ;
  }
  SampleBuffer::SampleBuffer(char const * astring)
  {
    int tmplen= strlen( astring) ;
    * m_buffer = new char[tmplen +1 ];
    m_len= tmplen ;
    strncpy( * m_buffer, astring, tmplen) ;
  }

Either you lived with two copies of the initialization code, or you created a private init() function which you called from both constructors. Not ideal, but I never worked in a group large enough that I had to worry about someone trying to call init() other than in the constructor. Still, it could happen, and that would probably be bad.

In C++11 they added constructor chaining which have shown up in other languages like c sharp and java. So now the constructors can look like this:

  SampleBuffer::SampleBuffer(int alen) : m_len(alen)
  {
    * m_buffer = new char[alen +1] ;
  }
  SampleBuffer::SampleBuffer(char const * astring) : DRYBuffer(strlen(astring))
  {
    strncpy( * m_buffer, astring, m_len) ;
  }

Already an improvement, especially if you decide to change something like having m_len represent the size of the buffer including the null terminator (heaven help you tracking down that off by one error in the original with the two separate code paths).

Obviously this is just an example (only a small step above the other trivial examples out there), but I've done the init() thing before for non-trivial cases, and this will be a handy alternative.

Of course there's the issue of where you can use this, and where you can't. It looks like g++ 4.6 does not support this, but g++ 4.7 on works fine.

Labels: c++, c++11, programming

  ¶ 2:00 PM