小编ale*_*099的帖子

考虑这个类

class A {
public:
    tracker tra;
    A(tracker _t) : tra(_t) {}
};

并通过调用它

A a {tracker()};

创建的对象tracker()在被存储到之前永远不会被使用a.tra

为什么编译器不优化所有的复制结构？

。

跟踪器定义如下：

class tracker {
public:
    void mark(const char* v) {
        std::cout << v << ' ' << this << std::endl;
    }

    tracker() {
        mark("con");
    }

    tracker(const tracker& o) {
        mark("cpy");
    }

    tracker(tracker&& o) {
        mark("mov");
    }

    ~tracker() {
        mark("des");
    }

    tracker& operator=(const tracker&) {
        mark("=cp");
        return *this;
    }

    tracker& operator=(tracker&&) {
        mark("=mv");
        return *this;
    }
};

如何获取类的实例？

大家都会回答：调用它的构造函数

喜欢 class_name()

那么如果类没有默认构造函数怎么办？

我有一个接受字节缓冲区作为参数的函数：

template<typename BUFFER>
void fun(BUFFER& buf) {

我需要对 进行一些限制BUFFER，所以我选择了最新的ranges

template<std::ranges::range BUFFER>
void fun(BUFFER& buf) {

这是一个字节缓冲区，因此 的返回类型std::ranges::begin(buf)应该是byte

然后我添加了一些要求

template<std::ranges::range BUFFER>
    requires std::same_as<byte, decltype(*std::ranges::begin(BUFFER()))>
void fun(BUFFER& buf) {

这不好，因为我们不知道是否BUFFER有默认构造函数

那么，有没有比下面的代码更好的解决方案呢？

template<typename T>
struct instanceof_t {
    T value;
};

template<typename T>
using instanceof = instanceof_t<T>::value;

template<std::ranges::range BUFFER>
    requires std::same_as<byte, decltype(std::ranges::begin(instanceof<BUFFER>))>
void fun(BUFFER& buf) {