Thread: STL problems

Originally Posted by Foxel

For example I can use min() and max() just including <cmath>, but if I change compiler I must include <algorithm> too.

This is not a problem for me, but it literally destroys portability (I tried the code on the same pc, so I can't imagine what could happen on anothe operating system)

From what I see, the C standard does not include min and max in <math.h>, hence there has been no version of the C++ standard that included std::min and std::max in <cmath>. Hence, it is likely that you were relying on an indirect inclusion of min and max (i.e., you included another header that happens to have included a header in which min and max as given in <algorithm> was declared), and so your code is not portable, as you discovered.

Originally Posted by Foxel

What can I do to be guaranteed that a given function can always be read by the compiler?

Check that the function is indeed provided for by the C++ standard, and is available by including a header that you included. This is best done with a copy of the C++ standard itself, but you could always use a draft version of the standard that is freely available online, or an online reference like cppreference.com and you'll more or less have the information you want.

You can also try to detect non-standard stuff by compiling your code at high warning levels and explicitly specifying the version of the C standard that you want, though this doesn't guarantee that an indirect inclusion that cannot be relied upon will not happen.

Always include the proper header as specified in your reference (such as cppreference.com). The proper header is, and as far as I know has always been, <algorithm>. Always compile using a specific standard and high warning level. These days you should be using C++11 at a bare minimum, better still C++14, and preferably C++17.

I think you are just assuming that min() was in <cmath>. It could've been defined inside <iostream>. For example, with g++ -std=c++11 -Wall -W -pedantic this compiles without warnings:

Code:

#include <iostream>
 
int main() {
    int a = 1, b = 2;
    std::cout << std::min(a, b) << '\n';
    std::cout << std::max(a, b) << '\n';
}

<iostream> is defined in the standard to include <ios> (which includes <iosfwd>), <streambuf>, <istream>, and <ostream>, as well as defining i/o objects like cout and cin. Apparently at least one of those headers in the g++ implementation that I used either includes <algorithm> (which seems unlikely) or simply defines min() and max() for its own use (presumably inline so there's no issue with multiple definitions).

But you cannot rely on that and should therefore always include the proper header.

Originally Posted by john.c

<iostream> is defined in the standard to include <ios> (which includes <iosfwd>), <streambuf>, <istream>, and <ostream>, as well as defining i/o objects like cout and cin. Apparently at least one of those headers in the g++ implementation that I used either includes <algorithm> (which seems unlikely) or simply defines min() and max() for its own use (presumably inline so there's no issue with multiple definitions).

But you cannot rely on that and should therefore always include the proper header.

For my installation of g++ it's getting included by /usr/include/c++/9/bits/char_traits.h (which is #including stl_algobase.h which is where max/min are for my installation; <algorithm> #includes stl_algobase.h. (Ultimately it's getting included because <ios> is including <exception> which leads to char_traits.h being included, leading to std_algobase.h inclusion)

g++ -M test.cpp
g++ -H test.cpp

Edit: I added the above just for curiosity's sake. Of course you're correct in saying that you should always include the correct file, and std::min and std::max have been in algorithm since c++98

So it's including part of algorithm but not the whole thing. Interestingly it doesn't define std::minmax. It's in stl_algo.h. But that's all implementation details since we of course wouldn't directly include either of those headers.