小编mkm*_*afa的帖子

我有一个add_custom_target触发项目的make(该项目不使用cmake!)并生成一个目标文件.我想将此对象文件添加到项目的cmake中的可执行目标.有没有办法做到这一点？

代码示例1:

namespace detail {
    enum enabler { dummy };
}

class foo {
public:
    template <typename T,
              typename std::enable_if<!std::is_integral<T>::value,
                                      detail::enabler>::type = detail::enabler::dummy>
    void func(T t) {
        std::cout << "other" << std::endl;
    }

    template <typename T,
              typename std::enable_if<std::is_integral<T>::value,
                                      detail::enabler>::type = detail::enabler::dummy>
    void func(T t) {
        std::cout << "integral" << std::endl;
    }
};

代码示例2:

namespace detail {
    enum enabler { dummy };
}

class foo {
public:
    template <typename T,
              typename T2 = typename std::enable_if<!std::is_integral<T>::value, detail::enabler>::type>
    void func(T t) {
        std::cout << …

template <typename>
struct B
{
    constexpr static int T = 5;
};

template <int T>
struct D : B<int>
{
    constexpr static int value = T;
};

int main()
{
    std::cout << D<7>::value << std::endl; // 5, how to get 7 ?
}

演示

正如我最近了解到,在查找期间在基类中的名称之后检查模板派生类的模板参数.话虽如此,无论如何都要限定名称T初始化value以引用T派生类的模板参数？

编辑:

到目前为止,评论中的讨论似乎是实现这一点的唯一方法是使基类类型/值依赖,这将延迟查找基数的名称(到实例化阶段),从而使唯一可用的值for T是模板参数.

#include <iostream>
#include <type_traits>

void func()
{

}

int main()
{
  using T = const decltype(func) &;
  using T2 = void (&)();
  std::cout << std::boolalpha << std::is_same_v<T, T2> << std::endl;
}

你如何声明const reference一个函数类型？上面的语句打印true所以我假设constin T以某种方式被忽略.是否有可能const reference将a 声明为函数类型？

struct X
    {
    enum class E
    {
        A,B
    };

    static constexpr X A()
    {
        return X{E::A};
    }

    static constexpr X B()
    {
        return X{E::B};
    }

    constexpr operator E() const
    {
        return a;
    }
    E a;
};

template <typename T>
struct Y
{
    void f()
    {
        // without this line clang errs
        // const auto & x = this->x;
        switch(x)
        {
            case X::A():
            case X::B():
            default: return;
        }
    }

    X x = X::A();
};

int main()
{
    Y<int>{}.f();
}

如果片段中没有标记行，则出现以下错误：

错误：case值不是常量表达式case …

template <typename T>
struct X
{
    template <typename Iter>
    X(Iter a, Iter b) {}

    template <typename Iter>
    auto f(Iter a, Iter b)
    {
        return X(a, b);
    }
};

在"C++模板,完整指南"第2版​​中,有前面的示例关于带有注入类名的隐式演绎指南的字幕.作者提到,对于注入的类名禁用了类参数推导,因为f的返回类型将X<Iter>归因于隐式推导指南.但我相信模板构造函数的隐式演绎指南更像是下面的那个.

  template <typename T, typename Iter>
  X(Iter a, Iter b) -> X<T>;

我的问题是如何将类模板参数类型,即使在这种情况下,可以推断T,并Iter有两种不同类型和参数类型的唯一依靠Iter.即使T可以某种方式推断出来,T并且Iter是独立的,所以Iter从论证中推断出来并不意味着它的X类型是X<Iter>正确的吗？这是书中的文字有些错误,还是演绎指南看起来与我的想法不同？

class Base {
public:
   virtual void f() {}
};

class Derived : private Base {
public:
   void f() override {}
};

我的问题是这样的覆盖是否有用？私有继承意味着您不能存储Derived在Base指针中,因此永远不需要动态分派f到正确的类型.

struct X\n{\n    template <typename>\n    struct Y;\n\n    template <>\n    struct Y<int>\n    {\n    };\n};\n

此代码无法使用 GCC （甚至 GCC 10 Link）进行编译，并出现以下错误消息

error: explicit specialization in non-namespace scope \'struct X\'\n

根据cpp参考

Explicit specialization may be declared in any scope where its primary template may be defined\n

我们还有此缺陷报告，其中行为已更改以允许此代码编译CWG 727

然而在这个问题上有一些评论

\n

到目前为止，这似乎还没有解决，gcc 开发人员声称 cwg727 从未获得批准。\xe2\x80\x93 斯威夫特 - Friday Pie Nov 22 \'19 at 19:11

\n

表示这份缺陷报告未获批准。真的吗？这是 gcc bug 不符合标准吗？

我的git仓库中有几个分支.我想知道是否有一个命令列出了某个分支中的所有标记而不是整个仓库中的所有标记.

我试过了 git tag --contains.但它没有按预期工作.

图1,有一个带有散列的所有标签的列表(标记的两个标签具有相同的散列/提交) 图2,你可以看到我在一个名为"b"的分支上 图3,我查询哪个分支包含两个标签的哈希值(两者都有相同的哈希),并且它表示它们位于分支"b"(我当前正在使用的那个)上

图4,描述了分支标签,它只给了我一个标签

图5,也描述了应该指向用两个标签标记的提交的哈希的标签,它只再次显示一个标签

#include <iostream>
using namespace std;

class A 
{
    public:
    A() : x(0) {}
    // notice: not identical to const version but does update
    void FA() {std::cout << "A" << std::endl; x++;}
    void FA() const {std::cout << "const A" << std::endl;}
    private:
    int x;
};

class B
{
    public:
    B() : x(0) {}
    // notice: not identical to const version but does update
    void FB() {std::cout << "B" << std::endl; x++;}
    void FB() const {std::cout << "const B" << std::endl;}
    private: …