c++-standard-library

Sample code: #include <iostream> #include <cmath> #include <stdint.h> using namespace std; static bool my_isnan(double val) { union { double f; uint64_t x; } u = { val }; return (u.x << 1) > 0x7ff0000000000000u; } int main() { cout << std::isinf(std::log(0.0)) << endl; cout << std::isnan(std::sqrt(-1.0)) << endl; cout << my_isnan(std::sqrt(-1.0)) << endl; cout << __isnan(std::sqrt(-1.0)) << endl; return 0; } Online compiler . With -ffast-math , that code prints "0, 0, 1, 1" -- without, it prints "1, 1, 1, 1". Is that correct? I thought that std::isinf / std::isnan should still work with -ffast

In most places where the C++ standard library allocates memory, the user is able to customise this by providing a class which meets the Allocator requirements . For example, almost all containers take an allocator template argument, and std::allocate_shared returns a shared_ptr whose contained element and control block are both allocated via a provided Allocator. However, there are a few places where the standard library can (potentially) allocate memory, but no Allocator support is provided. The ones I can think of are: std::make_unique() (no corresponding allocate_unique() ) std::any std:

First, I'm assuming that calling any function of std::chrono is guaranteed to be thread-safe (no undefined behaviour or race conditions or anything dangerous if called from different threads). Am I correct? Next, for example on windows there is a well known problem related to multi-core processors that force some implementations of time related systems to allow forcing a specific core to get any time information . What I want to know is: using std::chrono, in the standard, is there any guarantee that think kind of problem shouldn't appear? or is it implementation defined or is there an

For a long time I was using std::vector and std::shared_ptr hand in hand. Recently I started using std::shared_ptr<const T> whenever a pointer to a const object was needed. This is all OK, since std::shared_ptr<T> can be cast to std::shared_ptr<const T> and then they share the same reference counter and everything feels natural. But when I try to use constructs such as std::vector< std::shared_ptr<const T> > I run into troubles. To simplify I will denote the two structures: template <class T> using SharedPtrVector = std::vector< std::shared_ptr<T> >; template <class T> using

I know that some C++ Standard Library headers are originated from the STL, such as vector . But I'm failing to find an up-do-date list of STL headers which are still not incorporated by the Standard Library. Do they exist? PS: I would like to have them listed, and also to know if all major implementations include them or where to get them, if possible. Note, this is a function by function break down, rather than a by header breakdown, because it seems to be more useful. If we examine SGI's documentation of the STL we find the following: slist has been renamed std::forward_list . bit_vector has

I'm trying to debug a program that has no source code available, and I need to look at what it has stored in a std::string. I've been Googling and looking on here, and I've found some information about outputting STL containers, but all of it refers to variables, with no source or debug information all I have is a memory offset of the class data. Is there any way to do this? Every std::string implementation has a pointer to the raw characters in it somewhere. For g++ 4.x , that pointer is at offset 0 into the string. If you know that the string resides at e.g. 0x7fffffffda88 , then print *