Global Variable "Count" Ambiguous

Global variable count ambiguous

The problem is all because of the second line here:

#include <algorithm>
using namespace std;

The line using namespace std brings all the names from <algorithm> which also has a function called count, and in your code, you've declared a variable count. Hence the ambiguous error.

The solution is to never write using namespace std. It is bad bad bad.

Instead, use std::cout, std::cin, std::endl, std::count and so on, in your code.

Unable to define a global variable in C++

count is defined in both your code and by the Standard Library (in the std namespace). Your use of using namespace std; to drag the entire Standard namespace into the global namespace creates an ambiguity. You should do at least one of the following:

• remove using namespace std from the global namespace; either use the namespace within your functions, or use just the names you need, or qualify all the standard names when you use them
  carefully choose your own names to avoid conflicts with standard names
• change the name count to ^*something else to avoid ambiguity.
• qualify the references to the global count, writing ::count.

---

^{*) Note in particular that the standard library also defines the name distance.}

Eclipse c++ not letting me use global variable?

Your problem is here:

using namespace std;

It brings in std::count from the algorithm header, so now count is ambiguous. This is why people are told not to do using namespace std;. Instead, remove that line and put std::cout instead of cout (and the same for cin and endl).

Using <bits/stdc++.h> gives a global variable ambiguity

std::count is a function from the standard library.

http://www.cplusplus.com/reference/algorithm/count/

Since you use the namespace std , "count" can refer to either std::count or the variable count.

You need to either rename your variable, or stop using the std namespace.

You can also include only the c++ headers that you need instead of bits/stdc++.h which includes all of them.

why is it giving an error saying reference to max is ambiguous in line 12 if(k>=max)?

It is because you are using std namespace:

using namespace std;

And there is already an std::max which conflicts with your variable max.

C++: using namespace, global variable won't work

name space std also declares name count. This name corresponds to the standard algorithm std::count.
So when you include the directive

using namespace std;

and when use unqualified name count like this

while(count--) {
//...
}

then there can be an ambiguity.

To resolve the ambiguity you should use a qualified name. For example

    using namespace std;

    //...

   while( ::count--) {
          ^^^^^^^^
       //...
   }

In general it is not a good idea to use the directive that can lead to such an ambiguity as in your example.

error using Xcode C++ when trying to use global variable

There is an STL algorithm named std::count() and as there is a using namespace std; directive the compiler now has two available count symbols to choose from: remove the using namespace std; and use std::cout.

See Using std Namespace for further reading.

Remove global implicit function - avoid ambiguous operator

I had written another answer to this question, but the OP pointed out that my answer was incorrect. Upon thinking about this more, I believe that what the OP is trying to do is simply not possible.

As described in C++17 [over.built]/16, during overload resolution, a built-in candidate is generated with the signature

bool operator==(PType, PType);

If the built-in candidate is selected, then the built-in semantics of == will apply.

Now, it is possible to define your own operator==, but unless you declare one with the same exact signature as the built-in candidate, the built-in candidate will still get generated. Thus, at overload resolution time, the built-in candidate either wins (due to exact match), or is tied with some user-declared overload, resultin in ambiguity.

If you do declare your own operator== with the exact signature of the built-in candidate, then the built-in candidate is not generated ([over.match.oper]/(3.3.4)). You are allowed to delete it if you wish:

bool operator==(PType, PType) = delete;

However, a deleted function still participates in overload resolution (unless it is a defaulted move constructor or move assignment operator). Therefore, this does not solve the problem: with additional overloads such as

bool operator==(PType&&, PType);

there is potential for ambiguity, and such ambiguity only arises once the argument types are actually known. That's why the compilation error doesn't occur until you actually try to use ==.

What you really want is some way to prevent the built-in candidate, or another function with the same signature, from being considered by overload resolution at all. If you could do so, then you could force an overload to be chosen based on value category from an overload set like the following:

bool operator==(const PType& lhs, const PType& rhs);
bool operator==(const PType& lhs, PType&& rhs);
bool operator==(PType&& lhs, const PType& rhs);
bool operator==(PType&& lhs, PType&& rhs);

But as far as I can see, there is no way to do this, so what the OP wants does not seem possible.

---

Related Topics