c++17

I tried to provide structures for checking is A is (choose cast)-castable to B . All four casts would have exact same implementation, expect their names (local-macro-able definitions would be possible, but not necessary). I wrote many check-for operators structures, for example: #include <iostream> #include <type_traits> #include <string> template<class, class, class, class = void> struct is_valid_ternary_operator : std::false_type { }; template<class T, class S, class R> struct is_valid_ternary_operator <T, S, R, std::void_t<decltype(std::declval<T>() ? std::declval<S>() : std::declval<R>())>

If I have a header foo.h which contains #ifndef FOO_H_ #define FOO_H_ namespace foo { constexpr std::string_view kSomeString = "blah"; } #endif // FOO_H_ then is it safe to include foo.h from within multiple .cc files in a single program, regardless of what they do with the symbol kSomeString , or are there some uses that could cause an ODR violation? Also, is it guaranteed that kSomeString.data() will return the same pointer across .cc files? I'd like specific references to wording in the C++ standard if possible. Thanks! Merely including foo.h from multiple translation units will not violate

I try to find a way in C++17 to shorten following function calls: GetCurrentContext()->GetEntityManager()->CreateEntity(); maybe to something like: EM()->CreateEntity(); I tried a function pointer, but this is only valid for static functions: constexpr auto &EM = GetContext()->GetEntityManager; // error: reference to non-static member function must be called; Is there a better solution than using a Macro? #define EM GetContext()->GetEntityManager When using an inline function call, i'm afraid, that the compiler will ignore this and i have an unnessessary overhead: inline EntityManager* EM() {

Does passing multiple arguments via ::std::initializer_list offer any advantages over the variadic function template method? In code: template <typename T> void f(::std::initializer_list<T> const); template <typename ...A> void f(A&& ...args); Note that the types A... can be restricted to a single type as well, through SFINAE or static_assert() . The arguments can be iterated through ... You can iterate over an std::initializer_list in a way that you cannot over a parameter pack (unless you have C++17 and you fold it first). So for example you can have for loops with the lists. With parameter

This question already has an answer here: How can you iterate over the elements of an std::tuple? 18 answers Does anyone know of a good, clean way to iterate over a tuple in C++17 / 20? Let's say we have a bit of code like this: class Test { public: Test( int x ) : x_(x) {}; void Go() const { std::cout << "Hi!" << x_ << "\n" ; } int x_; }; int main() { std::tuple tplb{ Test{1} , Test{2} , Test{3} }; } How could we iterate through the tuple and call the Go() method on each using the latest 17/20 features? I know you could just have a vector of the object and then it works easily. My goal with

Context In mathematics-related context, I'd like to define functors working on <cmath> functions. For the purpose of this question, we will be using std::invoke as our functor. This is ill-formed (live demo) : std::invoke(std::sin, 0.0); (g++-8.1) error: no matching function for call to 'invoke(<unresolved overloaded function type>, double)' Indeed, std::sin is an overload set and the compiler lacks the type information to choose one of those functions. Question How could I name a specific function from an overload set? With what could we replace LEFT and RIGHT so that the following is well

I try to create a templated wrapper for different functions with different parameters. The setup is a class A with the basic implementation of two methods foo and bar . Another class B shall wrap these methods and add new functionality. The solution from the following link works very well for non-class functions: c++11: Templated wrapper function But if I try to invoke methods from another class I get an error. #include <algorithm> #include <functional> #include <iostream> class A { public: void foo(int x) { std::cout << "Foo: " << x << std::endl; } void bar(int x, float y) { std::cout << "Bar

I'm using c++17, and would like to write the code something like this, #include <variant> typedef int NewInt; int main() { std::variant<NewInt, int> n = 1; } But it emits compile error, po.cpp: In function ‘int main()’: po.cpp:5:35: error: conversion from ‘int’ to non-scalar type ‘std::variant<int, int>’ requested std::variant<NewInt, int> n = 1; ^ How could I define the type like std::variant<NewInt, int> or is it impossible? A type alias is just another name for an existing type, not a new type. So you have a variant of two ints. And while it's allowed, you must address the ambiguity