c++17

C++17 introduces std::aligned_alloc and alignment-aware new that can do over-aligned allocations, but what about std::allocator ? Does it handle over-aligned types? In N4659(C++17 DIS), 23.10.9.1 [allocator.members], bullet 2 T* allocate(size_t n); Returns: A pointer to the initial element of an array of storage of size n * sizeof(T), aligned appropriately for objects of type T . Compared to C++14, the sentence It is implementation-defined whether over-aligned types are supported has been removed. So std::allocator should support over-aligned types in C++17. 来源： https://stackoverflow.com

When implementing a custom container I came to the point where I needed to implement iterators. Of course I didn't want to write the code twice for const and non-const iterator. I found this question detailing a possible implementation like this: template<class T> class ContainerIterator { using pointer = T*; using reference = T&; ... }; template<class T> class Container { using iterator_type = ContainerIterator<T>; using const_iterator_type = ContainerIterator<const T>; } But I also found this this question that uses a template parameter: template<class T, bool IsConst> class

I have a one-to-many map class - MyMap1N<WeakPtr_Parent,WeakPtr_Children> . By design, it is supposed to store weak pointers of game-related instance. Roughly speaking, it is called like :- MyMap1N<WeakPtr<Room>,WeakPtr<RigidBody>> map; WeakPtr<Room> room=create<Room>(); WeakPtr<RigidBody> body=create<RigidBody>(); map.add(room,body); MyArray<WeakPtr<RigidBody>> bodys=map.getAllChildren(room); By profiling, I found that std::unordered_map is too slow. Thus, I had to find another way to implement it. I decided to create an array (instead of unordered_map ) in Room . To increase speed of query,

Consider this code: void f(char * ptr) { auto int_ptr = reinterpret_cast<int*>(ptr); // <---- line of interest // use int_ptr ... } void example_1() { int i = 10; f(reinterpret_cast<char*>(&i)); } void example_2() { alignas(alignof(int)) char storage[sizeof(int)]; new (&storage) int; f(storage); } line of interest with call from example_1: Q1: On the callside the char pointer is aliasing our integer pointer. This is valid. But is it also valid to just cast it back to an int? We know an int is within its lifetime there, but consider the function is defined in another translation unit (with no

I'd like to initialize a static std::map where the value is not copyable. I'll call my class ValueClass . ValueClass has an std::unique_ptr as private member and I even ensure that ValueClass is not copyable by extending non_copyable that looks like the following: class non_copyable { public: non_copyable() = default; protected: virtual ~non_copyable() = default; private: non_copyable(const non_copyable&) = delete; non_copyable& operator=(const non_copyable&) = delete; }; Now I'm trying to define a std::map using my class as value: static std::map<int, ValueClass> value_classes = { {0,

At cppref , I see a weird type trait checker : std::has_unique_object_representations From its description, I cannot imagine any type T that make std::has_unique_object_representations<T>::value is false . Is there any counter-example? Understanding the purpose of this trait requires understanding the distinction between an objects "value representation" and its "object representation". From the standard: The object representation of an object of type T is the sequence of N unsigned char objects taken up by the object of type T , where N equals sizeof(T) . The value representation of an object