小编Any*_*orn的帖子

我试图使用类型特征添加对模板参数的引用.

template < class T >
struct S {
typename add_reference< T >::type reference; // reference member should always be a reference
};
...
typedef Bar< Foo > type;
S< type > s; // does not add reference, S:: reference is of type type, not type&

但它似乎不起作用.这是正确的方法吗？我的编译器是g ++ 4.3.谢谢.

澄清:无论是否实例化S <type>或S <type&>,我都希望引用成员作为引用.

我想知道原始整数类型的计算哈希值(例如std :: map key)之间的速度是否存在差异,例如int64_t和pod类型struct { int16_t v[4]; };.那么int128_t与struct {int32_t v[4];}？

我知道这将是特定于实现的,所以我的问题最终与gnu标准库有关.谢谢

我发现的链接非常有用 如何在boost :: unordered_map中使用自定义类型的键？

我有这样的模板:

100 template<size_t A0, size_t A1, size_t A2, size_t A3>
101 struct mask {
103     template<size_t B0, size_t B1, size_t B2, size_t B3>
104     struct compare {
105         static const bool value = (A0 == B0 && A1 == B1 && A2 == B2 && A3 == B3);
106     };
107 };
...
120 const typename boost::enable_if_c<
121 mask<a,b,c,d>::compare<2,3,0,1>::value || ...>::type

我试图实例化比较结构.如何在第121行获得价值？

我似乎不明白如何捕获构造函数异常.这是相关代码:

     struct Thread {
            rysq::cuda::Fock fock_;
            template<class iterator>
            Thread(const rysq::cuda::Centers &centers,
                   const iterator (&blocks)[4])
                : fock_()
            {
                if (!fock_) throw;
           }
      };

      Thread *ct;
      try { ct = new Thread(centers_, blocks); }
      catch(...) { return false; } // catch never happens,

所以catch语句不执行,我得到未处理的异常.我做错了什么？这是使用g ++的直接C++.

我有C/C++代码,看起来像这样:

static int function(double *I) {
    int n = 0;
    // more instructions, loops,
    for (int i; ...; ++i)
        n += fabs(I[i] > tolerance);
    return n;
}

function(I); // return value is not used.

编译器内联函数,但它没有优化n操作.我希望编译器能够识别该值从不用作rhs.是否有一些副作用,这会妨碍优化？

编译器似乎并不重要,我试过Intel和gcc.积极优化, -O3

谢谢

更完整的代码(完整代码是重复这样的块):

  280         // function registers
  281         double q0 = 0.0;
  282         double q1 = 0.0;
  283         double q2 = 0.0;
  284
  285 #if defined (__INTEL_COMPILER)
  286 #pragma vector aligned
  287 #endif // alignment attribute
  288         for (int a = 0; …

我知道我可以y[i] += f(x[i])使用两个输入迭代器进行转换.然而,它似乎有点违反直觉,比循环更复杂.

有没有更自然的方法来使用boost或Stl中的现有算法.我找不到干净的等价物.

这里是变换(y = y + a*x):

using boost::lambda;
transform(y.begin(), y.end(), x.begin(), y.begin(), (_1 + scale*_2);
//  I thought something may exist:
transform2(x.begin(), x.end(), y.begin(), (_2 + scale*_1);
// it does not, so no biggie. I will write wrapper

谢谢

这个片段有pythonic表达式吗？

# linux.cmd is a dict
cmd = linux.cmd.get(k, k)
if not cmd:
    cmd = k

价值linux.cmd.get[k]可能是False.

给定矩阵乘积C = A*B,有没有N^2办法估算C的最大值？或者更确切地说,这样做的好方法是什么？

我有两个::tensor::contract和::tensor::detail::contract

#include "tensor/detail/contract.hpp"

namespace tensor {


    template<typename Alpha, class A, class B, typename Beta, class C>
    void contract(Alpha alpha, A a, B b, Beta beta, C c) {
        detail::contract(alpha, a, b, beta, c);
    }

    template<class A, class B, typename U = int>
    struct contract_expression :
        expression<contract_expression<A,B,U> >
    {
        template<typename T, class C>
        void evaluate(T alpha, T beta, expression<C> &c) const {
            contract(alpha*alpha_, a, b, beta, c); // ambiguity here
        };
    };

为什么我会模棱两可contract_expression::evaluate？我相当确定没有流浪using指令.

错误: …

我有以下循环:

for (int ij =  begin; ij < ni*nj; ij += step) {
    int j = ij/ni;
    int i = ij - j*ni;
    ...
}

i,j没有div/mod 可以计算什么其他选项？

展开循环不是一种选择.