c++14

问题 I am trying to compile C++14 project of mine with gcc 6.3 and I am getting: hm3/pairblob.cc: In static member function 'static std::unique_ptr<hm3::PairBlob> hm3::PairBlob::create(const hm3::PairBlob*)': hm3/pairblob.cc:64:44: error: exception cleanup for this placement new selects non-placement operator delete [-fpermissive] std::unique_ptr<PairBlob> pair{ new(size) PairBlob }; ^~~~~~~~ In file included from /usr/include/c++/6.3.1/ext/new_allocator.h:33:0, from /usr/include/c++/6.3.1/armv7l

问题 basically I am trying to have a tuple/list which contains a dictionary of different data types of values(float/int/bool/char/list) in python. I am getting this from the following code: (<f_p.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x7f4954bdde10> >, <f_p.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x7f4954bdde40> >, <f_p.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x7f495668be70> >, <f_p.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x7f4952d09a50> >) I want to get

问题 This question already has answers here : What is the use of a constexpr on a non-const member function? (2 answers) Closed 12 months ago . I cannot understand the purpose of marking the setter function as constexpr , that is allowed since C++14. My misunderstanding comes from the next situation: I declare a class with a constexpr c-tor, and I am about to use it in a constexpr context, by creating a constexpr instance of that class constexpr Point p1 . An object p1 now is constant and its

问题 I'm trying to write a Bind metaprogramming template helper metafunction that binds a template parameter to something. I have a working implementation for simple template metafunctions: template<typename T0, typename T1> struct MakePair { using type = std::pair<T0, T1>; }; template<template<typename...> class TF, typename... Ts> struct Bind { template<typename... TArgs> using type = TF<Ts..., TArgs...>; }; using PairWithInt = typename Bind<MakePair, int>::type; static_assert(std::is_same

问题 It seems to me that it's a very basic and necessary feature of any functional programming language to know the order in which the arguments of a function call will be evaluated. Am I wrong in this? Why doesn't C++ define this? Is it being discussed for any future version of C++? 回答1: Why doesn't C++ do it this way? For starters, C++ isn't a functional programming language. And the fastest way to evaluate the arguments depends on the implementation and architecture, so the compiler gets to

问题 Consider this code snippet: bool foo(const std::string& s) { return s == "hello"; // comparing against a const char* literal } bool bar(const std::string& s) { return s == "hello"s; // comparing against a std::string literal } At first sight, it looks like comparing against a const char* needs less assembly instructions 1 , as using a string literal will lead to an in-place construction of the std::string . ( EDIT: As pointed out in the answers, I forgot about the fact that effectively s

问题 Consider this code snippet: bool foo(const std::string& s) { return s == "hello"; // comparing against a const char* literal } bool bar(const std::string& s) { return s == "hello"s; // comparing against a std::string literal } At first sight, it looks like comparing against a const char* needs less assembly instructions 1 , as using a string literal will lead to an in-place construction of the std::string . ( EDIT: As pointed out in the answers, I forgot about the fact that effectively s

问题 Consider this code snippet: bool foo(const std::string& s) { return s == "hello"; // comparing against a const char* literal } bool bar(const std::string& s) { return s == "hello"s; // comparing against a std::string literal } At first sight, it looks like comparing against a const char* needs less assembly instructions 1 , as using a string literal will lead to an in-place construction of the std::string . ( EDIT: As pointed out in the answers, I forgot about the fact that effectively s

问题 As far as I understand - generic lambdas are transformed into objects of local scope structs with templated operator() . This makes generic lambda very powerful and easy to use tool. On the other hand one can create structs nested into the function, when however the struct has templated member e.g.: #include <iostream> int main() { struct inner { template <class T> void operator()(T &&i) { } }; return 0; } or is templated by itself: int main() { template <class T> struct inner { void operator

问题 Consider the following classes foo1 and foo2 template <typename T> struct foo1 { T t_; foo1(T&& t) : t_{ std::move(t) } { } }; template <typename T> struct foo2 { foo1<T> t_; foo2(T&& t) : t_{ std::forward<T>(t) } { } }; Is it always the case that the constructor of foo1 represents the correct way to initialise the member variable T ? i.e. by using std::move . Is it always the case that the constructor of foo2 represents the correct way to initialise the member variable foo1<T> due to needing