小编Rus*_*lan的帖子

假设我有一个A带有整数模板参数的模板类和一个派生B自 的特化的类A（可能有许多具有不同特化的此类派生类A）。我希望能够询问B其基类有什么模板参数，并从基类调用相应的静态函数。

使用 C++11 关键字很容易做到这一点constexpr，但 C++03 中不存在这样的关键字。因此，此代码无法在 C++03（据称）兼容行上使用 C++11 编译器进行编译：

template<int N>
struct A
{
    static const int getN() { return N; }
    static constexpr int getNc() { return N; }

    static int g(const A& a) { return 123; }
};

struct B : public A<4>
{   
};

int main()
{
    A<B::getNc()>::g(B()); // OK in C++11
    A<B::getN()>::g(B()); // FAIL in any C++ version
}

那么，问题是，如何在 C++03 中实现同样的效果？也许有一些语法糖可以避免A …

考虑这段代码：

#include <tuple>
#include <string>
#include <iostream>
#include <unordered_map>    
int main()
{
    std::unordered_map<int,std::string> map {{5,"five"},{1,"one"},{-7,"minus seven"}};
    int x;
    std::string s;
    for(std::tie(x,s) : map)
        std::cout << x << "->" << s << "\n";
}

在这里，for我从 clang++-3.6 收到错误：

test.cpp：14：23：错误：对于范围声明必须声明一个变量

这似乎意味着我无法std::tie打开包装，如果我这样做的pair话。valfor(auto val: map)

但我真的很想自动解压该对，而无需在循环体中添加任何额外的行。还有什么优雅的方式来实现这一点吗？

我正在尝试创建一个内核模块来为x87 FPU启用FOP兼容模式.这是通过设置IA32_MISC_ENABLEMSR中的位2来完成的.这是代码:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <asm/msr-index.h>
#include <asm/msr.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("10110111");
MODULE_DESCRIPTION("Module to enable FOPcode compatibility mode");
MODULE_VERSION("0.1");

static int __init fopCompat_init(void)
{
   unsigned long long misc_enable=native_read_msr(MSR_IA32_MISC_ENABLE);
   printk(KERN_INFO "Before trying to set FOP_COMPAT, IA32_MISC_ENABLE=%llx,"
                    " i.e. FOP_COMPAT is %senabled\n"
                    ,misc_enable,misc_enable&MSR_IA32_MISC_ENABLE_X87_COMPAT?"":"NOT ");

   wrmsrl(MSR_IA32_MISC_ENABLE,misc_enable|MSR_IA32_MISC_ENABLE_X87_COMPAT);
   misc_enable=native_read_msr(MSR_IA32_MISC_ENABLE);

   printk(KERN_INFO "Tried to set FOP_COMPAT. Result: IA32_MISC_ENABLE=%llx,"
                    " i.e. FOP_COMPAT is now %senabled\n"
                    ,misc_enable,misc_enable&MSR_IA32_MISC_ENABLE_X87_COMPAT?"":"NOT ");
   return 0;
}

static void __exit fopCompat_exit(void)
{
   const unsigned long long misc_enable=native_read_msr(MSR_IA32_MISC_ENABLE);
   printk(KERN_INFO "Quitting FOP-compat with …

我正在测试各种double在C ++ 中格式化s的方法，下面是一些代码：

#include <chrono>
#include <cstdio>
#include <random>
#include <vector>
#include <sstream>
#include <iostream>

inline long double currentTime()
{
    const auto now = std::chrono::steady_clock::now().time_since_epoch();
    return std::chrono::duration<long double>(now).count();
}

int main()
{
    std::mt19937 mt(std::random_device{}());
    std::normal_distribution<long double> dist(0, 1e280);
    static const auto rng=[&](){return dist(mt);};
    std::vector<double> numbers;
    for(int i=0;i<10000;++i)
        numbers.emplace_back(rng());

    const int precMax=200;
    const int precStep=10;

    char buf[10000];
    std::cout << "snprintf\n";
    for(int precision=10;precision<=precMax;precision+=precStep)
    {
        const auto t0=currentTime();
        for(const auto num : numbers)
            std::snprintf(buf, sizeof buf, "%.*e", precision, num);
        const auto …

我正在为我的班级写一个打印方法,例如:

std::ostream& operator<<(std::ostream& stream, const MyClass& M);

在里面我需要创建一个中间体stringstream,以便我后来把我得到的字符串放到了正确的位置stream.但是stream可能有一些非默认设置,如精度,字段宽度,数字格式等.

如何将所有这些格式设置复制stream到我的stringstream,而无需手动对每个设置进行"读取和设置"？

考虑以下C代码(假设为80位long double)(注意,我知道memcmp,这只是一个实验):

enum { sizeOfFloat80=10 }; // NOTE: sizeof(long double) != sizeOfFloat80
_Bool sameBits1(long double x, long double y)
{
    for(int i=0;i<sizeOfFloat80;++i)
        if(((char*)&x)[i]!=((char*)&y)[i])
            return 0;
    return 1;
}

我检查的所有编译器(gcc,clang,icc on gcc.godbolt.org)生成类似的代码,这里是gcc选项的示例-O3 -std=c11 -fomit-frame-pointer -m32:

sameBits1:
        movzx   eax, BYTE PTR [esp+16]
        cmp     BYTE PTR [esp+4], al
        jne     .L11
        movzx   eax, BYTE PTR [esp+17]
        cmp     BYTE PTR [esp+5], al
        jne     .L11
        movzx   eax, BYTE PTR [esp+18]
        cmp     BYTE PTR [esp+6], al
        jne     .L11
        movzx   eax, BYTE …

我试图理解这段代码的作用。这应该否定系数模coeff类型uint64_t*为 的多项式的modulus_value类型系数const uint64_t：

std::int64_t non_zero = (*coeff != 0);
*coeff = (modulus_value - *coeff) & static_cast<std::uint64_t>(-non_zero);

到底怎么了& static_cast<std::uint64_t>(-non_zero)？这怎么能否定任何事情呢？

代码来自这里。

我正在尝试创建一个条件表达式来初始化一些函数,变量等.在C中看起来像这样的东西:

#if option==1
  int foo(int x){/*some code here*/}
  int q=10;
#else
  char foo(int x){/*some other code*/}
  double q=3.141592;
#endif
use_q(q);
f(some_var);

在Mathematica中,我尝试过使用If,像这样:

If[option==1,
foo[x_]=some_expression1;
q=10;
,
foo[x_]=some_expression2;
q=3.141592;
]
use_q[q];
f[some_var];

但结果是函数的参数被涂成红色,并且在If中没有任何内容被初始化或计算.那么,我该怎样做才能获得有条件的"编译"？

自 GLSL 4.20 起const，限定变量不再需要通过常量表达式进行初始化。但是，当我实际尝试定义const由非常量表达式初始化的全局限定变量时，Mesa 会发出错误。这是示例代码：

#version 420
uniform vec2 v;
const float x=v.x;

out vec4 color;
void main()
{
    color=vec4(x,v.y,0,1);
}

以下是我测试编译的方法（以避免任何 OpenGL 代码）：

#version 420
uniform vec2 v;
const float x=v.x;

out vec4 color;
void main()
{
    color=vec4(x,v.y,0,1);
}

如果我将const float x=v.x;行移到函数体中main，编译将成功结束。

OTOH，nvidia 驱动程序（像往常一样）更加宽容，接受原始代码而不发出警告。

那么，GLSL 4.20+ 实际上是否禁止const在全局范围内使用 -限定变量的非常量表达式初始值设定项，或者这个错误是 Mesa 错误吗？