C getters setters coding style

Question

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 amp  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 amp  name   const   return name     make the field public since it s a constant   Thanks

User · 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.

User · Answer

Even though the name is immutable  you may still want to have the option of computing it rather than storing it in a field   I realize this is unlikely for  name   but let s aim for the general case   For that reason  even constant fields are best wrapped inside of getters   class Foo       public          const std  string amp  getName   const  return name        private          const std  string amp  name        Note that if you were to change getName   to return a computed value  it couldn t return const ref  That s ok  because it won t require any changes to the callers  modulo recompilation

User · Answer

I think the C  11 approach would be more like this now    include  lt string gt   include  lt iostream gt   include  lt functional gt   template lt typename T gt  class LambdaSetter   public      LambdaSetter             getter   amp     - gt  T   return m value              setter   amp   T value    m value   value              m value               T operator       return getter          void operator   T value    setter value          LambdaSetter operator  T rhs                setter rhs           return  this             T operator  LambdaSetter rhs                return rhs getter               operator T                  return getter                void SetGetter std  function lt T   gt  func    getter   func        void SetSetter std  function lt void T  gt  func    setter   func         T amp  GetRawData     return m value     private      T m value      std  function lt const T   gt  getter      std  function lt void T  gt  setter       template  lt typename TT gt      friend std  ostream  amp  operator lt  lt  std  ostream  amp os  const LambdaSetter lt TT gt  amp  p        template  lt typename TT gt      friend std  istream  amp  operator gt  gt  std  istream  amp is  const LambdaSetter lt TT gt  amp  p       template  lt typename T gt  std  ostream  amp  operator lt  lt  std  ostream  amp os  const LambdaSetter lt T gt  amp  p        os  lt  lt  p getter        return os     template  lt typename TT gt  std  istream  amp  operator gt  gt  std  istream  amp is  const LambdaSetter lt TT gt  amp  p        TT value      is  gt  gt  value      p setter value       return is      class foo   public      foo                 myString SetGetter   amp     - gt  std  string                myString GetRawData      Hello               return myString GetRawData                        myString2 SetSetter   amp   std  string value  - gt  void                myString2 GetRawData      value                                  LambdaSetter lt std  string gt  myString      LambdaSetter lt std  string gt  myString2      int  tmain int argc   TCHAR  argv          foo f      std  string hi   f myString       f myString2    world        std  cout  lt  lt  hi  lt  lt       lt  lt  f myString2  lt  lt  std  endl       std  cin  gt  gt  f myString2       std  cout  lt  lt  hi  lt  lt       lt  lt  f myString2  lt  lt  std  endl       return 0      I tested this in Visual Studio 2013   Unfortunately in order to use the underlying storage inside the LambdaSetter I needed to provide a  GetRawData  public accessor which can lead to broken encapsulation  but you can either leave it out and provide your own storage container for T or just ensure that the only time you use  GetRawData  is when you are writing a custom getter setter method

User · Answer

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   public      std  string const amp  name   const              Getter     void name std  string const amp  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   public         Getter     std  string const amp  operator     const           return  compute fancy name          Does some internal work               Setter     void operator   std  string const amp  newName             set fancy name newName             Does some internal work                   class Foo   public      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

User · Answer

As an aside  in C    it is somewhat odd to have a const reference member   You have to assign it in the constructor list   Who owns the actually memory of that object and what is it s lifetime   As for style  I agree with the others that you don t want to expose your privates   -   I like this pattern for setters getters  class Foo   public    const string amp  FirstName   const    Foo amp  FirstName const string amp  newFirstName      const string amp  LastName   const    Foo amp  LastName const string amp  newLastName      const string amp  Title   const    Foo amp  Title const string amp  newTitle        This way you can do something like   Foo f  f FirstName  Jim   LastName  Bob   Title  Programmer

User · Answer

Collected ideas from multiple C   sources and put it into a nice  still quite simple example for getters setters in C     class Canvas   public      void resize             cout  lt  lt   resize to    lt  lt  width  lt  lt       lt  lt  height  lt  lt  endl             Canvas int w  int h    width  this   height  this            cout  lt  lt   new canvas    lt  lt  w  lt  lt       lt  lt  h  lt  lt  endl          width value   w          height value   h             class Width   public          Canvas amp  canvas          int value          Width Canvas amp  canvas   canvas canvas             int  amp  operator    const int  amp i                value   i              canvas resize                return value                    operator int    const               return value                  width       class Height   public          Canvas amp  canvas          int value          Height Canvas amp  canvas   canvas canvas             int  amp  operator    const int  amp i                value   i              canvas resize                return value                    operator int    const               return value                  height      int main         Canvas canvas 256  256       canvas width   128      canvas height   64      Output   new canvas 256 256 resize to 128 256 resize to 128 64   You can test it online here  http   codepad org zosxqjTX  PS  FO Yvette  lt 3

User · Answer

From the Design Patterns theory   encapsulate what varies   By defining a  getter  there is good adherence to the above principle  So  if the implementation-representation of the member changes in future  the member can be  massaged  before returning from the  getter   implying no code refactoring at the client side where the  getter  call is made   Regards

User · Answer

Avoid public variables  except for classes that are essentially C-style structs   It s just not a good practice to get into   Once you ve defined the class interface  you might never be able to change it  other than adding to it   because people will build on it and rely on it   Making a variable public means that you need to have that variable  and you need to make sure it has what the user needs   Now  if you use a getter  you re promising to supply some information  which is currently kept in that variable   If the situation changes  and you d rather not maintain that variable all the time  you can change the access   If the requirements change  and I ve seen some pretty odd requirements changes   and you mostly need the name that s in this variable but sometimes the one in that variable  you can just change the getter   If you made the variable public  you d be stuck with it   This won t always happen  but I find it a lot easier just to write a quick getter than to analyze the situation to see if I d regret making the variable public  and risk being wrong later    Making member variables private is a good habit to get into   Any shop that has code standards is probably going to forbid making the occasional member variable public  and any shop with code reviews is likely to criticize you for it   Whenever it really doesn t matter for ease of writing  get into the safer habit

[c++] C++ getters/setters coding style

Examples related to c++

Examples related to coding-style

Examples related to getter-setter