小编Ziz*_*Tai的帖子

假设我们有一个Foo带有非explicit构造函数的类int.然后为以下功能:

Foo makeFoo1() { return 123; }
Foo makeFoo2() { return {123}; }

我认为makeFoo1要求Foo复制/移动ctor是可访问的,并且可能(尽管不太可能)编译器不会删除副本,从而导致真正的复制/移动.

对于makeFoo2,因为我们使用的副本列表初始化,可以永远不发生复制/移动.

我是否真的应该担心这个问题,并且explicit只要我能够(如同makeFoo2)在非支持者中提出论据？(假如我是图书馆作者,并希望该库与subpar编译器一起用于嵌入式系统.)

考虑这个例子：

import React, { useCallback } from 'react';

type UserInputProps = {
  onChange: (value: string) => void;
};

const UserInput = React.memo(({ onChange }: UserInputProps) => {
  // Is this `useCallback` redundant?
  const handleChange = useCallback(
    (event) => {
      onChange(event.target.value);
    },
    [onChange]
  );

  return <input type="text" onChange={handleChange} />;
});

export default UserInput;

我的问题是：

1. 当 props 只包含onChange而不包含其他元素时，useCallback在这种情况下是不必要的，因为整个组件已经基于onChange?
2. 如果我们添加一个额外的道具（比如 avalue的初始值<input>），那么我认为useCallback变得有用，因为否则handleChange即使onChange不改变但value被改变也会重新创建。那是对的吗？

以下两个定义之间的任何方面(句法限制,性能等)是否有任何差异？

using Foo = struct { int a, b, c; };

struct Foo { int a, b, c; };

(我问的是,因为第一种形式在许多using声明中放在美学上更均匀.)

编辑:评论中链接的帖子并不完全回答我的问题.我更关注上述两个定义在使用方面的差异,而那篇文章主要回答了它们是如何区别的,以及它们是什么,我认为.

在这个参考页面上std::tuple,据说该类型的默认构造函数是"显式的,当且仅当Ti对于至少一个不是隐式可默认构造的i".

我对"隐式默认构造"意味着什么感到困惑.有人能举个例子吗？

当我注意到 Firefox 的这种行为时，我正在做一些本地开发。我有一个运行在http://127.0.0.1:8080（没有 TLS）的本地开发服务器，它用一个安全的、仅主机的 cookie 响应 Firefox，如下所示：

• 姓名： "__Host-my-session"
• 领域： "127.0.0.1"
• 仅主机： true
• 仅Http： true
• 小路： "/"
• 同一站点： "Strict"
• 安全的： true

我想因为这是一个安全的 cookie，所以我的本地非 TLS 开发服务器应该无法读取它。但是，Firefox 能够很好地将此 cookie 发送到我的本地开发服务器，而 Safari 不会发送它。

这是 Firefox 中帮助本地测试的特例，还是我在做/理解错误？

假设我有一个班级Option:

template<typename T>
class Option {
public:
    Option() noexcept
    {}

    Option(T val) noexcept : val_(std::make_shared<T>(std::move(val)))
    {}

    const T & get() const
    {
        if (val_ == nullptr) {
            throw std::out_of_range("get on empty Option");
        }
        return *val_;
    }

    const T & getOrElse(const T &x) const
    {
        return val_ == nullptr ? x : *val_;
    }

private:
    std::shared_ptr<T> val_;
};

传递给的参数Option::getOrElse是当它Option为空时返回的默认值:

Option<int> x;  // empty
int y = 123;
x.getOrElse(y);  // == 123

但是,我认为以下代码不安全:

Option<int> x;
x.getOrElse(123); …

如此页面所示,std::optional<T>::value_or未标记rvalue ref-qualified版本constexpr:

template< class U >
constexpr T value_or( U&& default_value ) const&;

template< class U >
T value_or( U&& default_value ) &&;

这背后的原因是什么？是因为值的移动可以修改optional对象吗？

但是,如果我们也制作&&版本constexpr,我们现在写的不是很好:

constexpr int x = std::optional<int>(123).value_or(456);

我正在学习如何使用条件noexcept并遇到这个问题.假设我有一个班级:

template<typename T>
class Wrapper {
public:
    Wrapper(T&& value) noexcept(/* ??? */)
        : value_(std::move(value))
    {}

private:
    T value_;
};

对于那/* ??? */部分,我认为我们可以使用noexcept(T(std::move(value)))或者std::is_nothrow_move_constructible<T>::value,直到我偶然发现它.

所以,如果我用noexcept(noexcept(T(std::move(value)))),严格来说,我认为"此构造noexceptIFF建设和破坏一个T就是noexcept"？

虽然扔掉的破坏者应该着火并烧毁.

这个页面说make_optionalC++ 17 中的函数返回一个constexpr optional<...>.我想(虽然我可能错了)这需要optional<T>有一个constexpr复制或移动构造函数.但是,这个页面也说不是这样的.

我不知道如何make_optional实现目前的C++ 1z草案.请参阅此帖子以获得澄清.是否有一些解决方法,或者它只是标准的草案/ cppreference的错误？

谁能帮我理解为什么这段代码编译得很好：

use actix_web::{App, HttpServer};
use anyhow::Result;

mod error;

#[actix_rt::main]
async fn main() -> Result<()> {
    HttpServer::new(|| App::new())
        .bind("127.0.0.1:8080")?
        .run()
        .await?;

    Ok(())
}

虽然这不编译：

use actix_web::{App, HttpServer};
use anyhow::Result;

mod error;

#[actix_rt::main]
async fn main() -> Result<()> {
    HttpServer::new(|| App::new())
        .bind("127.0.0.1:8080")?
        .run()
        .await
}

有错误：

error[E0308]: mismatched types
 --> src/main.rs:6:1
  |
6 | #[actix_rt::main]
  | ^^^^^^^^^^^^^^^^^ expected struct `anyhow::Error`, found struct `std::io::Error`
7 | async fn main() -> Result<()> {
  |                    ---------- expected `std::result::Result<(), anyhow::Error>` because of return type
  |
  = …