Home > Articles > Programming > C/C++

  • Print
  • + Share This
Like this article? We recommend

Like this article? We recommend

Namespaces and Symbol Conflicts

Let’s say that we’re engaged in a bit of recreational code porting. An example might be porting code from one operating system to another or incorporating code from an old library into a new code base. Figure 1 illustrates the process.

Figure 1

Figure 1 Porting code from one location to another

Let’s assume that we really need and want the code that’s being ported, but we don’t know it all that well. Further, let’s assume that we encounter a function that clashes with a function of the same name in the target code. What to do? To illustrate the problem in Listing 5, I added a function called myFunction to EventHandler.cpp.

Listing 5 Our Source Code Just Before Porting the New Code

void myFunction(void)
{
   cout << "Hello from original myFunction(void)\n";
}

So, after porting the code we now have the following illegal situation in EventHandler.cpp:

Listing 6 Duplicate Symbols in the Merged Code

void myFunction(void) // The old function
{
   cout << "Hello from original myFunction(void)\n";
}

void myFunction(void) // The newly ported function
{
   cout << "Duplicate myFunction(void)\n";
};

So, we now have two functions in the one compilation unit with the same name. To illustrate a solution using namespaces, take a look at Listing 7, in which we add two new user-defined namespaces: one called originalCode and the other called duplicateSymbols.

Listing 7 Two New Namespaces to Solve the Symbol Clash

namespace originalCode
{
void myFunction(void)
{
   cout << "Hello from original myFunction(void)\n";
}
}

namespace duplicateSymbols
{
void myFunction(void)
{
   cout << "Duplicate myFunction(void)\n";
};
}

In Listing 7, we can see the two newly added namespaces called originalCode and duplicateSymbols, respectively. Now, I can call these functions as and when I like with the following code in Listing 8:

Listing 8 Qualified Symbol Names Using the Namespaces

   originalCode::myFunction();
   duplicateSymbols::myFunction();

As you can see, the calls to myFunction() are now qualified with a namespace and the scope resolution operator ::. In a way, we’ve added something to the name of each of the duplicate functions, and that something is a namespace.

Clearly, another solution is to rename the incoming (or ported) version of myFunction(), but I wanted to show how to solve the problem using namespaces. This approach has the merit that it would get the ported code compiling fairly quickly. Naturally, this solution mandates that any other calls to these functions be qualified similar to Listing 8.

  • + Share This
  • 🔖 Save To Your Account