How to Resolve a Name Conflict in C++?

In C++, naming conflict occurs when two identifiers in the same scope have the same name and the compiler cannot infer which identifier to refer to when it is mentioned in the program.

In this article, we will discuss what are name conflicts, what are its causes, and how to resolve the name conflict in C++.

Name Conflict Error in C++

As discussed in the introduction, the name conflict occurs when two or more identifiers have the same name in the same scope.

For example, look at the following code snippet:

C++

// C++ Program to illustrate the name confict error
#include <iostream>
using namespace std;

int main()
{
    int x = 10;

    // This will cause a Name Conflict Error
    double x = 20.5;
    return 0;
}

Output

main.cpp: In function ‘int main()’:
main.cpp:10:12: error: conflicting declaration ‘double x’
   10 |     double x = 20.5;
      |            ^
main.cpp:7:9: note: previous declaration as ‘int x’
    7 |     int x = 10;
      |         ^

Cases of Name Conflict Errors in C++

Above is not the only case of this error, it can occurs in many other cases. Below are some common cases of this error:

1. Global and Local Variables with the Same Name
2. Function Overloading with Same Parameter Types
3. Same Names in Different Namespaces
4. Same Names in Class and Derived Class
5. Same Name of Function Object(Functor) and Function

How to Resolve Name Conflict Error in C++

We can easily revolve the name conflict error by renaming the identifier which is causing it. But if you really need to use the same name, here are some other methods to do that:

1. Using Namespaces
2. Using Scope Resolution Operator

1. Resolve Name Conflict Error Using Namespace

Namespace feature was introduced in C++ exactly for resolving the name conflicts. This feature provide a separate space of each idenfier with same name and we can access them using its namespace.

Example

C++

// C++ Program to demonstrate how to use namespaces to
// resovle name conflicts in two classes
#include <iostream>
#include <string>

// Define namespaces
namespace my_namespace1 {
class Student {
public:
    std::string name;
    int age;

    // Constructor
    Student(std::string name, int age)
        : name(name)
        , age(age)
    {
    }

    // Method to display student details
    void display()
    {
        std::cout << "Name: " << name << "\nAge: " << age
                  << std::endl;
    }
};
} // namespace my_namespace1

namespace my_namespace2 {
class Student {
public:
    std::string name;
    int age;
    int roll;

    // Constructor
    Student(std::string name, int age, int roll)
        : name(name)
        , age(age)
        , roll(roll)
    {
    }

    // Method to display student details
    void display()
    {
        std::cout << "Name: " << name << "\nAge: " << age
                  << "\nRoll: " << roll << std::endl;
    }
};
} // namespace my_namespace2

int main()
{
    // Creating object of Student class from my_namespace1
    std::cout << "Student 1 Details: " << std::endl;
    my_namespace1::Student s1("John", 25);
    s1.display();

    // Creating object of Student class from my_namespace2
    std::cout << "\nStudent 2 Details: " << std::endl;
    my_namespace2::Student s2("Ravi", 30, 25);
    s2.display();

    return 0;
}

Output

Student 1 Details: 
Name: John
Age: 25

Student 2 Details: 
Name: Ravi
Age: 30
Roll: 25

2. Resolve Name Conflict Error Using Scope Resolution Operator

This method is used to resolve the name conflict in the case where the local variable and global variable have same name. We just access the global variable using scope resolution operator.

Example

C++

// C++ Program to demonstrate how to resolve name conflict
// in local and global variable

#include <iostream>

int x = 10; // Global variable

void func()
{
    int x = 20; // Local variable

    // Accessing the local variable 'x'
    std::cout << "Local x: " << x << std::endl;

    // Accessing the global variable 'x' using scope
    // resolution operator
    std::cout << "Global x: " << ::x << std::endl;
}

int main()
{
    func();
    return 0;
}

Output

Local x: 20
Global x: 10