Avoid writing two version of a function by hiding/unhiding lines of code

Question

There are two versions of a function (the code below is a simplified version). Both versions are used in the program. In the actual function, the differences between the two versions can occur at two or three different places.

How to avoid writing both versions in the code without sacrificing performance, through template or other means? This is an attempt to make the code more readable.

Performance is critical because it will get run many many times, and I am writing benchmark for different implementations.

(Also, is this an ok api, if I am writing a library for a few people?)

Example:

int set_intersect(const int* A, const int s_a,
                  const int* B, const int s_b,
                  int* C = 0){

    //if (int* C == 0), we are running version
    //0 of the function.

    //int* C is not known during compilation
    //time for version 1.

    int Count0 = 0;
        //counter for version 0 of the function.

    const int* const C_original(C);
        //counter and pointer for version 1 of
        //the function

    int a = 0;
    int b = 0;
    int A_now;
    int B_now;

    while(a < s_a && b < s_b){
        A_now = A[a];
        B_now = B[b];
        a += (A_now <= B_now);
        b += (B_now <= A_now);
        if (A_now == B_now){    
            if (C == 0){
                Count0++;
            } else {
                C++;
                *(C)=A_now;
            }
        }
    }
    if (C == 0){
        return Count0;
    }else{
        return C - C_original;
    }
}

Thanks.

---

Updates:

Conditional compile-time inclusion/exclusion of code based on template argument(s)

(some of those templates look so long)

Remove/Insert code at compile time without duplication in C++

(this is more similar to my case. my case is simpler though.)

---

I guess the following can work, but it adds a new argument.

int set_intersect(const int* A, const int s_a,
                  const int* B, const int s_b,
                  int* C = 0,
                  char flag);

put all code for version 0 into if (flag == '0') { /* version 0 code */ }

put all code for version 1 into if (flag == '1') { /* version 1 code */}

Probably can put the flag variable into template (as Barmar suggested in comments), that way, it doesn't feel like adding another argument for the function. Can also replace the 0 and 1 with enum (like enum class set_intersection_type {find_set, size_only}). Calling the function will be like set_intersect<find_set>(const int* A, const int s_a, const int* B, const int s_b, int* C) or set_intersect<size_only>(const int* A, const int s_a, const int* B, const int s_b) Hopefully this is more readable than before, and the compiler is smart enough to see what is going on.

Another problem is, what if someone uses the findset version (version 1), and then forgets to change the default argument (int C* = 0)? It is possible to call the function this way: set_intersect<find_set>(const int* A, const int s_a, const int* B, const int s_b).

May be I can use dasblinkenlight's idea in the comments. Create two wrapper functions (set_intersection, set_intersection_size). Each wrapper calls the actual function with different arguments. Also list the actual function as a private function so no one can call it directly.

For the different implementations of set intersections, maybe can create a common wrapper with templates. Calling the wrapper would be similar to set_intersection<basic>, set_intersection<binary_search>, or set_intersection_size<simd> etc. This seems to look better.

Answer 1

Generally seems doable, question is whether you want to do that. Would say no. From what I can tell you do two different things:

1. Version 0 computes the size of the intersection
2. Version 1 computes the size of the intersection, and writes the intersection to the location past C*, assuming there is enough space to store it.

I would not only for speed, but also for clarity make two distinct functions, set_intersection and set_intersection_size, but if you insist on having one I would benchmark your code against std::set_intersection, and if possible just redirect to the ::std version if C != 0.

In your current version I would not use your library. However I would also be hard-pressed to come up with a situation where I would prefer a custom-made version of set_intersection to the STL version. If I ever needed performance better than the STL, I would expect to have identified the point in code as the bottleneck, and I would not use a library call at all, but write the code myself, possibly in assembly and unrolling the loop etc..

What bugs me a bit is how this is supposed to work:

const int* const Count1(C);
    //counter and pointer for version 1 of
    //the function
...
    Count1++;
    *(Count1)=A_now;

Answer 2

If it is known at compilation time what version you want you can use Conditional Compilation.

#define Version_0 //assuming you know this compilation is version 0

Then you can go:

int set_intersect(...)
#ifdef Version_0
    //Version 0 of the code
#else
    //Version 1 of the code

This way only one version of the code gets compiled.

If you don't know which version it is for compilation, I suggest having two separate functions so you don't have to check for the version every instance of the function.

Answer 3

Have a type that you specialize on a bool parameter:

template<bool b>
struct Counter
{
};

template<>
struct Counter<false>
{
    int c;

    Counter(int *)
    : c(0)
    {
    }

    int operator++() { return ++c; }
    void storeA(const int a_now) {}
};

template<>
struct Counter<true>
{
    const int* const c;

    Counter(int * c_orig)
    : c(c_orig)
    {
    }

    int operator++() { return ++C; }
    void storeA(const int a_now) { *C = a_now; }
}

Then specialize your algorithm on Counter as a template argument. Note that this will be exactly the same for both cases, that is, you don't need to specialize:

template<typename Counter>
struct SetIntersectHelper
{
    static int set_intersect(const int* A, const int s_a,
                             const int* B, const int s_b,
                             int* C)
    {
        // your function's body, using Counter
    }
};

Now, you're ready to add the generic method:

int set_intersect(const int* A, const int s_a,
                  const int* B, const int s_b,
                  int* C = 0)
{
    return C ? SetIntersectHelper< Counter< true  > >::set_intersect(A, s_a, B, s_b, C):
               SetIntersectHelper< Counter< false > >::set_intersect(A, s_a, B, s_b, C);
}