小编asc*_*ler的帖子

模板类std::iterator设置为在C++ 17中弃用.为什么这样？它是确保std::iterator_traits工作的一种方便方法,特别是如果您可以使用默认模板参数.在C++ 17中还有其他一些方法吗？

您可能熟悉enum位掩码方案,例如:

enum Flags {
    FLAG1 = 0x1,
    FLAG2 = 0x2,
    FLAG3 = 0x4,
    FLAG4 = 0x8,

    NO_FLAGS = 0,
    ALL_FLAGS = FLAG1 | FLAG2 | FLAG3 | FLAG4
};

f(FLAG2 | FLAG4);

我已经看过很多代码,然后在掩码中测试一下

if ((mask & FLAG3) == FLAG3)

但这不等于这个吗？

if (mask & FLAG3)

有没有理由使用第一个版本？在我看来,第二个较短的版本更清晰.

也许C程序员的剩余习惯应该转换为真正的价值观1？(即使在那里,较长的版本在赋值或return语句中比在条件语句测试中更有意义.)

这可能是一件非常简单的事情,但我是C++的新手,所以需要帮助.

我只想在我的C++头文件中声明一个数组,如:

int lettersArr[26];

然后在cpp文件的函数中定义它,如:

    lettersArr[26] = { letA, letB, letC, letD, letE, letF, letG, letH,
        letI, letJ, letK, letL, letM, letN, letO, letP, letQ, letR, letS,
        letT, letU, letV, letW, letX, letY, letZ };

但这不起作用.

我的语法有错吗？这是正确的方法是什么？

非常感谢.

有时,在使用C++模板进行编码时,您希望阻止用户实例化特定的特化或一组特化,因为结果将是荒谬的.因此,您可以定义(特定或部分)特化,如果实例化,其定义将导致编译器错误.如果用户"误用"模板,目标将是在头文件中的注释旁边引发编译器错误,解释不应该做什么,而不是让编译器自己提出一些令人困惑的错误消息设备,或者可能允许编译可疑代码.

例:

template <typename T> struct MyClassTemplate {
  // ...
};

template <typename T> struct MyClassTemplate<T*> {
  // Do not use MyClassTemplate with a pointer type!
  typedef typename T::intentional_error err;
};

有很多方法可以做到这一点(取决于你的专业化是一个类或函数的完全或部分特化).但是使用的语法必须(？)依赖于模板参数,否则编译器会在首次解析故意错误定义时抱怨.上面的例子有一个漏洞,有人可能会顽固地定义一个intentional_error嵌套类型或成员typedef(虽然我会说他们会因此而得到任何问题).但是,如果你使用的技巧过于花哨,你很可能会得到一个难以理解和/或误导性的编译器错误消息,这大部分都会失败.

是否有更好的直接方法来禁止模板实例化？

我知道在C++ 0x中,模板Concepts和删除的函数声明将更好地控制这类事情,但我正在寻找有效的C++ 03答案.

我正在阅读Constraints上的cppreference页面并注意到这个例子:

// example constraint from the standard library (ranges TS)
template <class T, class U = T>
concept bool Swappable = requires(T t, U u) {
    swap(std::forward<T>(t), std::forward<U>(u));
    swap(std::forward<U>(u), std::forward<T>(t));
};

我很困惑他们为什么要用std::forward.有些人试图在模板参数中支持引用类型吗？我们不想swap用forward左值调用,并且当标量(非参考)类型时T,表达式不是rvalues U吗？

例如,我希望这个程序在Swappable实现时失败:

#include <utility>

// example constraint from the standard library (ranges TS)
template <class T, class U = T>
concept bool Swappable = requires(T t, U u) {
    swap(std::forward<T>(t), std::forward<U>(u));
    swap(std::forward<U>(u), std::forward<T>(t)); …

我已经阅读了MATLAB关于多线程的信息以及它在某些函数中的内置方式.但是,我的要求是不同的.说,我有3个函数:fun1(data1),fun2(data2),fun3(data3)....我可以在这些函数之间实现多线程吗？我实际上有300多个使用大量数据的函数.多线程可以帮助我减少很多时间.请建议一个我可以进一步研究的命令或其他东西.谢谢!

为什么static_assert需要在类定义的一边？

失败的代码

#include <type_traits>

class A
{
public:
    A(A&&) noexcept {}
    static_assert(std::is_nothrow_move_constructible<A>::value, "ERROR");
};

int main()
{
}

工作代码

#include <type_traits>

class A
{
public:
    A(A&&) noexcept {}

};

static_assert(std::is_nothrow_move_constructible<A>::value, "ERROR");

int main()
{
}

什么时候在类或结构的定义中使用static_assert是否合适？

我很惊讶在g ++的各种采样版本中,以下编译没有错误或警告:

// Adapted from boost::checked_delete()
template <class T> inline void assert_complete()
{
  typedef char type_must_be_complete[ sizeof(T) ? 1 : -1 ];
  (void) sizeof(type_must_be_complete);
}

class X;

void f()
{
  assert_complete<X>();
}

class X {};

int main() {}

如果X缺少定义或在不同的翻译单元中,我会收到错误.

但是在上面的程序中,是不是f我的模板的单个实例化点的定义？X那个实例化的不完整性是不是语义错误？

(C++ 03和/或C++ 11草案)标准是否将此程序称为格式良好,格式错误,格式错误但不需要诊断或未定义的行为？

编辑:@David Rodriguez - dribeas报告clang ++,comeau和Visual Studio 2010也接受类似的代码.

C++ 03和C++ 11在[temp.friend]的第一段中有:

[编辑报价.首先尝试错过措辞的第二个区别.]

对于不是模板声明的友元函数声明:

1. 如果朋友的名字是限定或不合格的模板ID,则友元声明引用功能模板的特化,否则

2. 如果friend的名称是qualified-id并且在指定的类或命名空间中找到匹配的nontemplate函数,则friend声明引用该函数,否则,

3. [C++ 03:]如果朋友的名字是qualified-id并且在指定的类或命名空间中找到了函数模板的匹配特化,则friend声明引用该函数模板特化,否则,

   [C++ 11:]如果朋友的名字是qualified-id并且在指定的类或命名空间中找到匹配的函数模板,则friend声明引用该函数模板的推导特化,否则,

4. 名称应为声明(或重新声明)普通(非模板)功能的非限定标识.

[措辞的变化看起来像是对我的澄清.虽然我猜可能有不同的方法来解释C++ 03关于"在类或命名空间中找到特殊化"的措辞.

我很好奇第三颗子弹.我编写此代码以尝试匹配其要求,但g ++ 4.8.1和clang ++ 3.4都拒绝代码,无论是使用-std = c ++ 03还是-std = c ++ 11:

template <class T> class R;
namespace N {
    template <class T> void test(const R<T>&);
}

template <class T>
class R {
    friend void N::test(const R<T>&);  // 8
    int m;
};

template <class T>
void N::test(const R<T>& rec) { rec.m; }

int main() { …

clang ++，g ++和MSVC 在以下代码上存在分歧：

class A {
private:
    enum class E { NO, YES };
    class B {
    private:
        friend E f1() { return E::YES; }
        // friend E f2();
    };
};

// A::E f2() { return A::E::YES; }

int main() {}

clang ++接受如下所示的代码。g ++以及MSVC抱怨在f1该A::E不可访问。如果f2未注释函数，则所有三个编译器都会抱怨其A::E无法访问的定义。

是f1在事实上是否有效？

我发现的相关标准件有：

[class.access.nest]：

嵌套类是成员，因此具有与任何其他成员相同的访问权限。

尽管仅此一项并不意味着嵌套类的朋友拥有与嵌套类相同的权限。

[class.access.base] / 5：

对成员的访问受该成员所在的类影响。该命名类是在其中查找并找到成员名称的类。如果在类中命名成员，m则可以在R点访问成员N

• m作为N公共成员，或

• m作为的成员N是私有成员，并且 …