Getters and Setters

[Semirxbih]

I still can't seem to grasp the whole setters and getters in C++

This is the assignment:

In this file, you declare a class named MyString.
– This class contains 3 private attributes, str, size, and strCount.
– str is a char* that points to a dynamic array of characters.
– size is an integer that contains the current size of the string.
– strCount is a static member variable that keeps track of the number of MyString objects that currently
exist in memory. Its value is initially 0 before any MyString object is created.
– Define public getters and setters for the 2 instance variables, as well as a getter for the static variable.

This is the code that I have so far,

#define MYSTRING_H
#ifndef MYSTRING_H

class MyString {

private:
  char* str[];
  int size;
  static strCount = 0;

public:
  void setStr(char * str) {
    str = s;
  }
  void getStr() {
    return str;
  }
  int setSize() {
    return size;
  }
  void getSize(int size) {
    size = sz;
  }
};

I would love if someone can point me in the right direction and help me define the static and char* getter and setters because I am having lots of trouble.

[wolle]

I still can't seem to grasp the whole setters and getters in C++

In its simplest form a getter and a setter are a pair of class functions which provide public access to a private class variable.

Say you have an object (obj) of a class defining a variable (var) of type T. If var is public you would access it like this

T v = obj.var; // get var directly
obj.var = v; // set var directly

If var instead is private but there are a getter and a setter available you would do this to the same effect,

T v = obj.getVar(); // get var indirectly
obj.setVar(v); // set var indirectly

For this to work the getter/setter must look like this,

T getVar () { // function to get var
    return var;
}
void setVar(T v) { // function to set var
    var = v;
}

Note that getters/setters should not be applied routinely. It is not that all private variables should have a public getter/setter pair. The purpose of getters/setters is to increase the level of abstraction but if overused without care they instead decrease abstraction and for this reason they are controversial.

Also getters/setters are not C++ specific. They're used in most languages and are even part of some languages (where they then appear as a language element usually called properties).

[2kaud]

There are some issues with the code.

#define MYSTRING_H
#ifndef MYSTRING_H

These are in the wrong order! For this to do as required, the test comes first before the define! Also, where is the closing #endif statement?

 static strCount = 0;

The type of strCount is missing. In this case type int is assumed but should be stated

 static int strCount = 0;

also you can't initialise a non-const static variable in the class. It has to be declared in the class and defined outside like

static int strCount;

and then outside of the class you have

int MyString::strCount = 0;

char* str[];

This is trying to define an array of unknown size of type char *. From the spec, don't you mean

char* str;

 void setStr(char * str) {
    str = s;
  }

Where does variable s come into this?? Don't you mean

 void setStr(char * s) {
    str = s;
  }

also as the contents of the memory pointed to by s doesn't change and the value of the pointer doesn't change, then a better definition could be

void setStr(const char * const s) {

void getStr() {
    return str;
  }

This is returning a value of type char *, but the function is defined as a void return type. Don't you mean

char* getStr() const {
    return str;
  }

also getter functions should be defined as const as they don't change the values of class variables.

 int setSize() {
    return size;
  }

The code is for a getter, so don't you mean

 int getSize() const {
    return size;
  }

likewise,

void getSize(int size) {
    size = sz;
  }

is for a setter, but where is sz defined?? Don't you mean

void setSize(int sz) {
    size = sz;
  }

You also need to provide the getter for strCount.

Note that for this exercise, use of setters for the variables is not a good idea and wouldn't be used in practice. Only getters would be used as these variables would be maintained by the class. As Wolle says in post #2, use of getters/setters should not be applied routinely (my highlight).