Why is abs not in std?

Your question is slightly wrong. abs is in std. Let me assume that you're asking "Why is abs also in the global namespace?".

The C++ standard allows the C standard functions to be declared in the global namespace in addition to being declared in the std namespace.

Why is this happening?

Because those functions are from the C standard library, and because standard allows it to happen, and because of the way your standard library was implemented.

How can I use these functions without cluttering my namespace?

Those names are reserved to the language implementation in the global namespace. There's no way to avoid it.

Don't treat the global namespace as "your namespace". The global namespace is cluttered, and it always will be. You need to work around that.

If not possible, are there c++ alternatives?

The C++ alternative is to declare your abs in your namespace:

namespace my_very_own_namespace {
    int abs;
}

You should declare everything¹ in your own namespace, except:

• That namespace itself
• main
• Template specialisations of names in other namespaces where that is allowed
• Cross-language API's i.e. anything extern "C"

The hardest part is figuring out a unique name for your own namespace, since it mustn't be one that is already used by the C standard library, nor preferably any name used by other libraries in the global namespace.

¹ Following this rule of thumb is hardly necessary when writing tiny exercise programs etc. But it becomes essential when writing large programs and relying on third party libraries, not to mention when writing those libraries for others to use.

Standard quotes:

[extern.names]

Each name from the C standard library declared with external linkage is reserved to the implementation for use as a name with extern "C" linkage, both in namespace std and in the global namespace.

Each function signature from the C standard library declared with external linkage is reserved to the implementation for use as a function signature with both extern "C" and extern "C++" linkage,171 or as a name of namespace scope in the global namespace.

[headers]

Except as noted in [library] through [thread] and [depr], the contents of each header cname is the same as that of the corresponding header name.h as specified in the C standard library. In the C++ standard library, however, the declarations (except for names which are defined as macros in C) are within namespace scope of the namespace std. It is unspecified whether these names (including any overloads added in [support] through [thread] and [depr]) are first declared within the global namespace scope and are then injected into namespace std by explicit using-declarations ([namespace.udecl]).

There is std::abs(int) and there is std::abs(float). The former is inherited from C abs(int). In C there is no overload for floating points, it is called fabs (also available as std::fabs).

You tripped over using namespace std; obfuscating what function is actually called. Note that you have it in main, but not in the header, which is actually good, but it still does harm in main, because once you place all code in main, suddenly a different function gets called. Without using namespace std;, abs(some_float) calls ::abs(int). With using namespace std;, abs(some_float) calls std::abs(float).

Note that the headers inherited from C are allowed but not guaranteed to introduce the names in the global namespace, so you could also get a compiler error.

Replace abs with std::abs and remove using namespace std. For more reasons to not pull in all names from std I refer you to Why is "using namespace std;" considered bad practice?

When you use

using namespace std;

you bring the following overloads of abs into scope:

std::abs(int)
std::abs(float)
std::abs(std::complex)

The call abs(f) resolves to std::abs(float).

If you don't use

using namespace std;

there is only one abs function that you are able to use.

abs(int)

Hence, the call abs(f) resolves to abs(int).

You can still remove the using namespace std; line and use std::abs(f) instead of just abs(f).

abs is not defined in <math.h>. It can be found in <stdlib.h> and it is also defined as std::abs in <cmath>.

In this case we actually can learn a lot from the standard.

C++98: In 26.5/Table 80 and 81 we learn that abs is in <cstdlib> and NOT <cmath>. But then in 26.5 we have the contradictory statement In addition to the double versions of the math functions in <cmath>, C++ adds float and long double overloaded versions of these functions, with the same semantics. which then lists abs as having additional overloads in <cmath> where the preceeding table said it should not be.

This is actually fixed in C++11 where 26.8/Table 119 clearly shows abs as a member of <cmath> as well as in <cstdlib> (although the added overloads for floating point types still appear exclusive to <cmath>.

As for your problem there are two likely situations:

1. You were compiling as C++11 before and are no longer doing so.
2. You were compiling C++98/03 but your standard libraries were updated to a version where <cmath> no longer implicitly includes <cstdlib> and your compiler was based on the table requirements rather than the implicit requirements of 26.5.

Most likely including <cstdlib> would fix the problem as would compiling in C++11 mode.