Two classes with same, standalone, hidden functionality

Question

There is one file with two separate classes and one function:

int foo(int x) {return x+x;}
class A {
    public:
    int bar(){return foo(0);} 
};
class B {
    public:
    int bar(){return foo(1);}
};

and they both need to use function

which uses only its argument (not use any data from A or B). I can declare this function as global. But i would like to hide this function for other files (so this is un visible, unacccesible in other files). So i can declare this function as member function of each class A and B. But this will be code duplicate.

What is the best practice for that?

Answer 1

You can just omit any declarations of foo from any headers, and mark it static or define it in an anonymous namespace.

AB.h

class A { int bar(); };
class B { int baz(); };

AB.cpp

static int foo(int x) { return x+x; }
/* or
namespace {
    int foo(int x) { return x+x; }
}
*/    


int A::bar() { return foo(1); }
int B::baz() { return foo(2); }

Answer 2

You can simply place the function inside another class that only exists in that file:

class C
{
public:
    static void foo(int) {}
};

class A
{
    void test1()
    {
        C::foo(0);
    }
};

class B
{
    void test2()
    {
        C::foo(0);
    }
};

A & B can access this function now and it's not being declared globally.

You can also put the function in its own namespace:

namespace ABFunctions
{
    void foo(int) {}
}

And that is another way of keeping it separated, logically.

If you need to protect access, you can do it this way:

class C
{
friend class A;
friend class B;
private:
    static void foo(int) {}
};

class A : C
{
    void test1()
    {
        C::foo(0);
    }
};

class B : C
{
    void test2()
    {
        C::foo(0);
    }
};

Now, only class A & B will have access to foo(int).

Answer 3

You can create a base class and derive from it. You won't have to duplicate code.

class Base {
    virtual ~Base = 0;
protected:
    int foo(int x) {return x+x;}
};

class A : public Base {...}
class B : public Base {...}

You can't instantiate an object of Base.

Answer 4

If it does not use any data from A or B, then it probably shouldn't be implemented within A or B. It sounds as if f was some kind of auxiliary function. Perhaps creating a class Utilities and making it a public static function of the utilities class would be better.

Answer 5

In c++ there's no hiding of functions at namespace level, though you can create a utility class that contains only private static functions, and explicitly specify which classes may have access using the friend keyword:

class C {
   friend class A;
   friend class B;
   static void foo(int);
};

int foo(int x) {return x+x;}
class A {
    public:
    int bar(){return C::foo(0);} 
};
class B {
    public:
    int bar(){return C::foo(1);}
};

Though that's not a very good design pattern, since friend introduces some more maintenance effort, as soon other classes than A or B need to access foo as well.

A probably better pattern is to use an interface as I've sketched out in my Q&A here:

• How can I remove/refactor a «friend» dependency declaration properly?

The introduction of interfaces there suffers from the overhead of virtual polymorphism though. Maybe that could be resolved with introduction of static polymorphism via the CRTP.

---

Regarding a wider view for maintenance and reusing implementation details, why are you trying to hide these as rigorously claimed for the function foo(). Why do you need to hide this implementation detail at all?