c++ - Preprocessor - Existential doubt

The problem in this case is that you are not properly isolating the different functions.

Preprocessor directives can bring a lot of flexibility to your code... but they are far from perfect:

• The more symbols you define, the more complicated it is to maintain the code.
• Code left out of a #ifdefdoesn't compile, forcing you to do multiple builds to test all the combinations (too expensive maintenance)
• The symbols are not typed, it's easy to get confused and put _CORTE_SECCION__instead of __CORTE_SECCION__... and then you spend hours identifying the problem.

It is advisable to isolate the different functionalities in classes or functions. With the new standards using templates is quite an affordable option.

I explain. Let's start with this code snippet:

#ifndef __CORTE_SECCION__
    worker = NULL;
#else
    multiWorker = NULL; 
#endif

// ...

#ifndef __CORTE_SECCION__
if (worker)
{
    disconnect(worker);
    delete worker;
    worker = NULL;
}
#else
if (multiWorker)
{
    disconnect(multiWorker);
    delete multiWorker;
    multiWorker = NULL;
}
#endif

Improving it and isolating the code here is relatively easy.

The first thing I would do is define a constant based on __CORTE_SECCION__:

#ifdef __CORTE_SECCION__
  constexpr bool IsMultiWorker = false;
#else
  constexpr bool IsMultiWorker = true;
#endif

We can then create a collection of templates for the different use cases (two in this case). Notice that you have not indicated the type of workerand multiworker. I will assume that they are Workerand Multiworker.

In any case, we are interested in creating a tool that allows us to create one Workeror one Multiworkerdepending on the circumstances:

template<bool>
struct MultiWorkerTraits;

template<>
struct MultiWorkerTraits<false>
{
  using type = Worker;
};

template<>
struct MultiWorkerTraits<true>
{
  using type = MultiWorker;
};

And then the disconnection functions. As the logic to be executed is the same, a single template is enough:

template<class T>
void Disconnect(T & worker)
{
  if( worker )
  {
    disconnect(worker);
    delete worker;
    worker = nullptr;
  }
}

We already have all the wickers ready, all that remains is to make changes to the original code snippet:

typename MultiWorkerTraits<IsMultiWorker>::type * worker = nullptr;

// ...

Disconnect(worker);

I'll give you a simple example.

We start a repository

git init

We add the initial files of the program

git add main.cpp Class1.cpp Class1.hpp

git commit -m "Initial program"

A client asks us for a very special thing that probably will not work for the rest. The fussy customer!! Well, we created a branch

git checkout -b gitclient

We add the new files and the modifications of the old ones

git add *

git commit -m "Busy client version ready"

Now we jump to our main version to continue improving the program

git checkout master

Added the improvements to the main branch

git add *

git commit -m "Added improvements"

And now we want to improve the version of the tiquismiquis client, so we go to its branch:

git checkout clienttiquismiquis

and merge with master

git merge master

Auto-merging main.cpp
CONFLICT (content): Merge conflict in main.cpp
Automatic merge failed; fix conflicts and then commit the result.

milk!!! It turns out that it cannot automatically merge them, so we open the conflicting file, leave it handy and continue

git add main.cpp

git commit -m "Merged improvements from master into gitclient"

All ready :-)