Question

The Google Style Guide for C++ says, in the section about smart pointers:

• We prefer designs in which objects have single, fixed owners.

I don’t fully understand the sentence.

• What is the object owner?
• Is it just the pointer?

Answer 1

The ‘owner’ of an object is not an actual part of the C++ language, but rather a conceptual tool – the idea being the ‘owner’ is in charge of deciding when the object can be destroyed. If an object has a single owner, it’s easy to figure out when the object needs to be destroyed – just look at the owner. When an object is referenced by multiple other objects, however, things are less clear – none of the referring objects can, on its own, delete the referee object, as this would cause problems for the other referers. So there there is no “single, fixed owner”.

To give some examples, consider a ‘picture’ object.

class Picture {
  char *rawData;
public:
  Picture(char *rawData_) : rawData(rawData_) { }
  Picture(const Picture &p) : rawData(p.rawData) { }
};

Picture does not own rawData; as we can see from the copy constructor, it’s all too easy to have multiple Pictures referencing the same data. A better version might look like:

class Picture {
  std::vector<char> rawData;
public:
  Picture(const std::vector<char> &rawData_) : rawData(rawData_) { }
};

This is similar, but now vector is hiding the raw pointer for us; it’s impossible to have two Pictures reference the same pointer. And we take care of destroying the rawData array when the Picture is destroyed. In this case, the Picture owns the raw data.

Now, you don’t have to use STL containers to have an owned object. You could do it manually:

class Picture {
  size_t rawDataSize;
  char *rawData;

public:
  Picture(size_t rds, char *rd) {
    rawDataSize = rds;
    rawData = new char[rds];
    memcpy(rawData, rd, rds);
  }

  ~Picture() { delete [] rawData; }

  Picture(const Picture &pic) {
    rawDataSize = pic.rawDataSize;
    rawData = new char[rawDataSize];
    memcpy(rawData, pic.rawData, rawDataSize);
  }

  Picture& operator=(const Picture &pic) {
    delete [] rawData;
    rawDataSize = pic.rawDataSize;
    rawData = new char[rawDataSize];
    memcpy(rawData, pic.rawData, rawDataSize);
    return *this;
  }
};

This is also an owning relationship; the rawData array ‘belongs’ to the picture object, permanently. All accesses go through the picture object, and it’s destroyed along with the picture object.

In general, with owning relationships, it’s recommended to use wrapper classes to automate destruction, and prevent accidental copying. In my third example, had I forgotten the copy constructor or operator=, for example, terrible things would happen. Using wrapper classes like std::unique_ptr, boost::scoped_ptr/boost::scoped_array, or std::vector (for owned arrays) help prevent you from making mistakes.