Question

I understand that one benefit of having static member functions is not having to initialize a class to use them. It seems to me that another advantage of them might be not having direct access to the class’s not-static stuff.

For example a common practice is if you know that a function will have arguments that are not to be changed, to simply mark these constant. e.g.:

bool My_Class::do_stuff(const int not_to_be_changed_1,
                        std::vector<int> const * const not_to_be_changed_2)
{
  //I can't change my int var, my vector pointer, or the ints inside it.
}

So is it valid to use static member functions to limit access. For example, lets say you have a function

void My_Class::print_error(const unsigned int error_no) {
  switch (error_no) {
    case 1:
      std::cout << "Bad read on..." << std::endl;
      break;
    //...
    default:
      break;
  }
}

Well here we’re not going to be accessing any member variables of the class. So if I changed the function to:

static void My_Class::print_error(const unsigned int error_no) {
  switch (error_no) {
    case 1:
      std::cout << "Bad read on..." << std::endl;
      break;
    //...
    default:
      break;
  }
}

I’d now get an error, if I inadvertently tried to access one of my private var, etc. (unless I pass myself an instance of my class, which would be purposeful ^_^ !)

Is this a valid technique, similar to proactively making args that should not be changed constants?

What downsides might it have in terms of efficiency or use?

My chief reason for asking is that most of the “static” tutorials I read made no mention of using it in this way, so I was wondering if there was a good reason why not to, considering it seems like a useful tool.

---

Edit 1: A further logical justification of this use:

I have a function print_error,as outlined above. I could use a namespace:

namespace MY_SPACE {
   static void print_error(...) {
      ...
   } 

   class My_Class {
      ....
      void a(void)
   }
}

But this is a pain, because I now have to lengthen ALL of my var declarations, i.e.

MY_SPACE::My_Class class_1;

all to remove a function from my class, that essentially is a member of my class.

Of course there’s multiple levels of access control for functions:

//can't change pointer to list directly
void My_Class::print_error(std::vector<int> const * error_code_list) {...}

//can't change pointer to list or list members directly
void My_Class::print_error(std::vector<int> const * const error_code_list) {...}

//can't change pointer to list or list members directly, access
//non-const member vars/functions
void My_Class::print_error(std::vector<int> const * const error_code_list) const {...}

//can't change pointer to list or list members directly, access
//non-static member vars/functions
static void My_Class::print_error(std::vector<int> const * const error_code_list) {...}

//can't change pointer to list or list members directly, access
//member vars/functions that are not BOTH static and const
static void My_Class::print_error(std::vector<int> const * const error_code_list) const {...}

Sure this is a bit atypical, but to lessening degrees so are using const functions and const variables. I’ve seen lots of examples where people could have used a const function, but didn’t. Yet some people think its a good idea. I know a lot of beginning c++ programmers who wouldn’t understand the implications of a const function or a static one. Likewise a lot would understand both.

So why are some people so adamantly against using this as an access control mechanism if the language/spec provides for it to be used as such, just as it does with const functions, etc.?

Answer 1

Static member functions should be used when they are relevant to the class but do not operate on an instance of the class.

Examples include a class of utility methods, all of which are static because you never need an actual instance of the utility class itself.

Another example is a class that uses static helper functions, and those functions are useful enough for other functions outside the class.