C++ getters/setters coding style


I have been programming in C# for a while and now I want to brush up on my C++ skills.

Having the class:

class Foo
    const std::string& name_;

What would be the best approach (I only want to allow read access to the name_ field):

  • use a getter method: inline const std::string& name() const { return name_; }
  • make the field public since it's a constant


4/26/2011 9:17:45 AM

Accepted Answer

It tends to be a bad idea to make non-const fields public because it then becomes hard to force error checking constraints and/or add side-effects to value changes in the future.

In your case, you have a const field, so the above issues are not a problem. The main downside of making it a public field is that you're locking down the underlying implementation. For example, if in the future you wanted to change the internal representation to a C-string or a Unicode string, or something else, then you'd break all the client code. With a getter, you could convert to the legacy representation for existing clients while providing the newer functionality to new users via a new getter.

I'd still suggest having a getter method like the one you have placed above. This will maximize your future flexibility.

5/27/2019 8:37:15 PM

Using a getter method is a better design choice for a long-lived class as it allows you to replace the getter method with something more complicated in the future. Although this seems less likely to be needed for a const value, the cost is low and the possible benefits are large.

As an aside, in C++, it's an especially good idea to give both the getter and setter for a member the same name, since in the future you can then actually change the the pair of methods:

class Foo {
    std::string const& name() const;          // Getter
    void name(std::string const& newName);    // Setter

Into a single, public member variable that defines an operator()() for each:

// This class encapsulates a fancier type of name
class fancy_name {
    // Getter
    std::string const& operator()() const {
        return _compute_fancy_name();    // Does some internal work

    // Setter
    void operator()(std::string const& newName) {
        _set_fancy_name(newName);        // Does some internal work

class Foo {
    fancy_name name;

The client code will need to be recompiled of course, but no syntax changes are required! Obviously, this transformation works just as well for const values, in which only a getter is needed.

Licensed under: CC-BY-SA with attribution
Not affiliated with: Stack Overflow