小编Vin*_*ent的帖子

我们考虑使用完全相同的语法创建两种不同类型的目标。这可以通过lambdas轻松完成：

auto x = []{};
auto y = []{};
static_assert(!std::is_same_v<decltype(x), decltype(y)>);

但是，我们正在寻找另一种更优雅的语法，而不是使用lambda。这是一些测试。我们首先定义一些工具：

#include <iostream>
#include <type_traits>
#define macro object<decltype([]{})>
#define singleton object<decltype([]{})>

constexpr auto function() noexcept
{
    return []{};
}

template <class T = decltype([]{})>
constexpr auto defaulted(T arg = {}) noexcept
{
    return arg;
}

template <class T = decltype([]{})>
struct object
{
    constexpr object() noexcept {}
};

template <class T>
struct ctad
{
    template <class... Args>
    constexpr ctad(const Args&...) noexcept {}
};

template <class... Args>
ctad(const Args&...) -> …

考虑std::vector v的N因素,并认为n第一要素已经整理与n < N何(N-n)/N很小:

有没有一种聪明的方法使用STL算法来比这更完整地对这个向量进行排序std::sort(std::begin(v), std::end(v))？

编辑:澄清:(Nn)未排序的元素应插入已排序的n个第一个元素中的正确位置.

EDIT2:奖金问题:以及如何找到n？(对应于第一个未排序的元素)

在我刚刚进行的测试之前,我相信只有构造函数不会在C++中继承.但显然,任务operator=不是......

1. 这是什么原因？
2. 是否有任何解决方法来继承赋值运算符？
3. 是不是也为的情况下operator+=,operator-=...？
4. 是否继承了所有其他函数(除了构造函数/运算符=)？

事实上,我在做一些CRTP时遇到了这个问题:

template<class Crtp> class Base
{
    inline Crtp& operator=(const Base<Crtp>& rhs) {/*SOMETHING*/; return static_cast<Crtp&>(*this);}
};

class Derived1 : public Base<Derived1>
{
};

class Derived2 : public Base<Derived2>
{
};

是否有任何解决方案可以使其工作？

编辑:好的,我已经解决了这个问题.为什么以下不起作用？如何解决问题？

#include <iostream>
#include <type_traits>

// Base class
template<template<typename, unsigned int> class CRTP, typename T, unsigned int N> class Base
{
    // Cast to base
    public:
        inline Base<CRTP, T, N>& operator()()
        {
            return *this;
        }

    // Operator =
    public: …

对于类型T为其中std::is_floating_point<T>::value的true,不C++标准规定上的任何方式T应实施？

例如,是否T甚至遵循符号/尾数/指数表示？或者它可以是完全随意的？

C++ 14标准为以下内容指定了以下声明std::exchange:

template <class T, class U = T>
T std::exchange(T& obj, U&& new_value);

我想知道为什么U违约,T因为U可以找到感谢new_value.在什么情况下,这会导致与以下结果不同的结果:

template <class T, class U>
T std::exchange(T& obj, U&& new_value);

我有一个抽象类(我知道它不会以这种方式编译,但它是为了理解我想要做的事情):

class AbstractComputation {
    public:
        template <class T> virtual void setData(std::string id, T data);
        template <class T> virtual T getData(std::string id);
};

class Computation : public AbstractComputation {
    public:
        template <class T> void setData(std::string id, T data);
        template <class T> T getData(std::string id, T data);
};

因此,当我打电话时,setData<double>("foodouble", data)我希望将foodouble(由此处不是主要关注的内部机制)识别的双精度设置为双精度数据.

那怎么办呢？

我认为通过输入类似的东西可能有一个意思,virtual void setData<double>(std::string id, double data)但我不知道该怎么做.

我在C++中有一个非常基本的问题.返回对象时如何避免复制？

这是一个例子:

std::vector<unsigned int> test(const unsigned int n)
{
    std::vector<unsigned int> x;
    for (unsigned int i = 0; i < n; ++i) {
        x.push_back(i);
    }
    return x;
}

据我了解C++是如何工作的,这个函数将创建2个向量:本地一个(x),以及将返回的x的副本.有没有办法避免副本？(我不想返回指向对象的指针,但是对象本身)

使用"移动语义"(在评论中说明)该函数的语法是什么？

我在matplotlib中有一个简单的情节,我想增加标题和情节之间的距离(不使用,suptitle因为它不适用于我在服务器上使用的版本).怎么做 ？

C++标准化委员会中有一个研究小组,在C++ 1z或之后提供编译时反射.我想知道预期工具的目的是什么以及功能有多强大？

例如,是否可以使用这些工具命名函数或类？

struct A {int f() {return 42;}};
struct B {int (std::reflect<A>::member<0>::declname)() {return 43;}};
// equivalent to struct B {int f() {return 43;}};

如果它没有这个那么强大,那么典型的用例是什么？

我目前正在创建一个带有constexpr构造函数的类,我想知道是否可以使用a std::array来存储此类的数据.标准是否明确指定a std::array具有constexpr构造函数,并且可以在编译时访问其内容？