-1

I want to update some C legacy code to C++. Suppose I had something similar to this code in C:

//my_struct.h
typedef struct myStruct {
//some members go here
} myStruct;

int f1(myStruct*);
void f2(myStruct*);

//my_struct.c
#include "my_struct.h"

static int helper(myStruct* st)
{
   return 21;
}

int f1(myStruct* st)
{
   return helper(st);
}

void f2(myStruct* st) {}

If I update it to the following in CPP:

//myStruct.h
struct myStruct {
   int f1();
   void f2();
private:
   int helper();
};

//myStruct.cpp
int myStruct::f1(){
   return helper();
}

void myStruct::f2(){}

int myStruct::helper(){
   return 21;
}

What is the impact of converting the global static C function to a private member function in C++?

What would be the pros/cons (regarding compilation, linking, runtime) between the previous approach and the following one? I didn't use the parameter inside the function to make the example short (If it is not used I read in other questions that it should probably go to the anonymous namespace).

//myStruct.h
struct myStruct {
   int f1();
   void f2();
}

//myStruct.cpp
namespace{
   int helper(myStruct *st){
      return 21;
   }
}
int myStruct::f1(){
   return helper(this);
}

void myStruct::f2(){}
vmp
  • 2,370
  • 1
  • 13
  • 17
  • IMO the first option is the best. – 273K Apr 20 '22 at 15:09
  • You’re exposing the function to the outside world. Compilation time will probably increase slightly due to richer interface and compiler will have to emit a symbol due to external linkage. The rest is subject to build settings, e.g. LTO; my guess is that members are less likely to be inlined, but I might be wrong here. – alagner Apr 20 '22 at 15:12
  • If `helper` doesn't really need `this` then second option, otherwise—first. – ixSci Apr 20 '22 at 15:21
  • Static functions is also a thing in C++. Anonymous namespaces were used to enable things to be used with templates, at a time when all template parameters had to have external linkage. That requirement was relaxed a long time ago. – BoP Apr 20 '22 at 17:14

1 Answers1

1

What is the impact of converting the global static C function to a private member function in C++?

The impact is that you've made a (private, internal) implementation detail of your module part of the (public) interface.

What would be the pros/cons (regarding compilation, linking, runtime) between the previous approach and the following one?

Cons:

  • you've added semantic noise to your interface

    ie, there's more for clients to read and think about, even though it shouldn't affect them,

  • changes to internal implementation details may require all clients of the interface to recompile, instead of just re-linking

    ie, if you want to change helper, that now updates the public header and causes widespread recompilation of files that shouldn't be affected

Pros:

  • there are none.

It's idiomatic in C++ to add implementation-file-local details like helper to the anonymous namespace.

Useless
  • 64,155
  • 6
  • 88
  • 132
  • Or static function in a cpp file. – ixSci Apr 20 '22 at 15:19
  • So the only good reason to have helper as a private member function is if needs to access private data that doesn't have getter methods? – vmp Apr 20 '22 at 15:44
  • Yes, in general. You may also want to use private methods when everything is inline (such as for templates), because there _is_ no implementation file to put them in. – Useless Apr 20 '22 at 15:54