小编das*_*fex的帖子

我有一些var = std::variant<std::monostate, a, b, c>什么时候a, b, c是一些类型。

如何在运行时检查var包含什么类型？

在官方文档中，我发现如果var包含a类型并且我写的信息，std::get<b>(var)我会得到一个异常。所以我想到了这个解决方案：

try {
  std::variant<a>(var);
  // Do something
} catch(const std::bad_variant_access&) {
  try {
    std::variant<b>(var);
    // Do something else
  } catch(const std::bad_variant_access&) {
    try {
     std::variant<c>(var);
     // Another else
    } catch (const std::bad_variant_access&) {
      // std::monostate
    }
  }
}

但它是如此复杂和丑陋！有没有更简单的方法来检查std::variant包含什么类型？

我可以将它用于什么目的？为什么它比 random_access_iterator 好？如果我使用它有什么好处吗？

import pandas as pd
import seaborn as sns

# load data
df = sns.load_dataset('penguins', cache=False)

sns.scatterplot(data=df, x='bill_length_mm', y='bill_depth_mm', hue='sex')
plt.show()
sns.scatterplot(data=df, x='flipper_length_mm', y='body_mass_g', hue='sex')
plt.show()

当我在 jupyter 中的一个单元格中用 seaborn 绘制两个图时，我得到以下视图：

我想并排绘制图，如下所示：

情节1 情节2

我该怎么做？

更新：

不是一个图形上的两个图，而是两个独立图形上的两个图。

• 这不是正在寻求的解决方案，因为它是一个图形上的两个图。

fig, ax = plt.subplots(1,2)
sns.plotType(someData, ax=ax[0])  # plot1
sns.plotType(someData, ax=ax[1])  # plot2
fig.show()

• 来自建议的重复ipython notebook的解决方案水平排列图，不起作用
  • 选项 with%html导致数字在彼此之上绘制
  • 此外，其他选项用于ipython，而不是 Jupyter，或建议创建子图。

这是我的层次结构：

aaaaaaaa
|_q
  |_a.txt
|_w
  |_l1
  |_l2

l1和l2~ are symlinks to a.txt`。我运行此代码以查找 /aaaaaaaa 中 a.txt 的所有符号链接：

find ~/aaaaaaaa/ -exec ls -a {} ';' | grep '/home/khodor/aaaaaaaa/q/a.txt'

它显然不起作用，因为我必须将文件的真实路径与a.txt. 我应该以什么方式做到这一点？

我知道它仅在 std::allocator 中被弃用和删除。我可以在我自己的分配器上实现它。但为什么它被弃用了呢？

我在我的项目中使用-fsanitize=leak和-fsanitize=address。我认为泄漏发现内存泄漏（不删除内存）和地址发现拧内存访问。但是地址也说明了未删除的内存。那么，-fsanitize=leak需要出于什么目的呢？

我想做这样的事情：

template <uint64_t N>
struct a {
  static constexpr T1 v1 = {};
  static constexpr T2 v2 = {};
  static constexpr auto v3 = (N % 2 == 1 ? v1 : v2);
};

但是我不能将 (? :) 用于不同类型。我怎么能做到这一点？

我有从中读取uint64_tval 的二进制文件（使用 little-endian）。现在我想将其转换uint64_t为double（不仅仅是转换，而是double我从文件中输入的数字）。所以应该有相同的位表示。我该怎么做？

如果我使用new并获取std::bad_alloc编译器，则不会因为异常而调用构造函数。但是它是如何处理nothrow new我们在每种情况下都得到指针的原因的呢？本案标准中是否有特殊段落？

我尝试做这样的事情

pair<int, int> f() {
    return {1, 2};
}

int a, b;
[a, b] = f();

并得到编译错误。所有错误都归结为一个事实，即编译器认为它是一个语法错误的 lambda。所以如果我使用结构化绑定，我总是应该写auto?

我们来看看这段代码：

A a(123);
new(&a) A(124);

测试表明，在这种情况下，当程序关闭时，析构函数~A()将调用一次。因此，如果A我们有一些指针作为字段，我们将会出现内存泄漏。

A a(123);
a.~A();
new(&a) A(124); 

这里一切都将是正确的。但根据标准，在析构函数调用后使用对象是未定义的行为（尽管大多数编译器提供的行为没有一些问题）。

我可以获取已调用析构函数的对象的地址吗？在堆栈变量上调用放置新是正确的操作吗？