小编Inv*_*rse的帖子

有没有办法看到在*nix中使用什么编译器和标志来创建可执行文件？我有一个旧版本的代码编译,我想看看是否编译有或没有优化.谷歌没有太大帮助,但我不确定我使用的是正确的关键词.

我正在为linux和windows编写一个应用程序,并注意到GCC构建产生了许多对复制构造函数的无用调用.

以下是产生此行为的示例代码:

struct A
{
    A()                { std::cout << "default" << std::endl; }
    A(A&& rvalue)      { std::cout << "move"    << std::endl; }
    A(const A& lvalue) { std::cout << "copy"    << std::endl; }
    A& operator =(A a) { std::cout << "assign"  << std::endl; return *this; }
};

BOOST_AUTO_TEST_CASE(test_copy_semantics)
{
    std::vector<A> vec_a( 3 );
}

此测试仅创建3个元素的向量.我期望3个默认构造函数调用和0个副本,因为没有A左值.

在Visual C++ 2010中,输出为:

default
move
default
move
default
move

在GCC 4.4.0(MinGW)中,( - 02 -std = c ++ 0x),输出为:

default
copy
copy
copy

发生了什么,我该如何解决？副本对于实际类来说是昂贵的,默认构造和移动都很便宜.

我正在添加新的运算符重载以利用c ++ 0x rvalue引用,我觉得我正在生成大量冗余代码.

我有一个类,tree它在双值上包含一个代数运算树.这是一个示例用例:

tree x = 1.23;
tree y = 8.19;
tree z = (x + y)/67.31 - 3.15*y;
...
std::cout << z; // prints "(1.23 + 8.19)/67.31 - 3.15*8.19"

对于每个二元运算(如加号),每一方可以是左值tree,右值tree或double.这导致每个二进制操作有8个重载:

// core rvalue overloads for plus:
tree operator +(const tree& a, const tree& b);
tree operator +(const tree& a, tree&&      b);
tree operator +(tree&&      a, const tree& b);
tree operator +(tree&&      a, tree&&      b);

// cast and forward cases: …

我想找到点,它具有较小的Y坐标(如果更多这样的点,找到具有最小X的那个).用lambda编写时:

    std::min_element(begin, end, [](PointAndAngle& p1, PointAndAngle& p2) {
        if (p1.first->y() < p2.first->y())
            return true;
        else if (p1.first->y() > p2.first->y())
            return false;
        else 
            return p1.first->x() < p2.first->x();
    }

我正进入(状态:

error C3499: a lambda that has been specified to have a void return type cannot return a value

有什么区别:

    // works
    std::min_element(begin, end, [](PointAndAngle& p1, PointAndAngle& p2) {
        return p1.first->y() < p2.first->y();
    }

和

    // does not work
    std::min_element(begin, end, [](PointAndAngle& p1, PointAndAngle& p2) {
        if (p1.first->y() < p2.first->y())
            return true;
        else …

我最近注意到了

_m128 m = _mm_set_ps(0,1,2,3);

在转换为float数组时,将4个浮点数置于相反的顺序:

(float*) p = (float*)(&m);
// p[0] == 3
// p[1] == 2
// p[2] == 1
// p[3] == 0

同样的情况union { _m128 m; float[4] a; }也发生了.

为什么SSE操作使用这种排序？这不是什么大问题,但有点令人困惑.

还有一个后续问题:

通过索引访问数组中的元素时,是应该按顺序访问0..3还是按顺序访问3..0？

这个问题只是半眯着眼睛.我有时会梦想没有裸阵或c弦的世界.

如果您使用的是c ++,那么main的首选定义不应该是:

int main(std::vector<std::string> args)

？

已经有多种定义main可供选择,为什么不存在符合C++精神的版本？

我一直在描述我的代码(下面显示的函数)中的一个瓶颈,它被称为数百万次.我可以使用提示来提高性能.这些XXXs数字来自Sleepy.

使用visual studio 2013 /O2和其他典型版本设置进行编译.

indicies通常为0到20个值,其他参数大小相同(b.size() == indicies.size() == temps.size() == temps[k].size()).

1:          double Object::gradient(const size_t j, 
2:                                  const std::vector<double>& b, 
3:                                  const std::vector<size_t>& indices, 
4:                                  const std::vector<std::vector<double>>& temps) const
5:  23.27s  {
6:              double sum = 0;
7:  192.16s     for (size_t k : indices)
8:  32.05s          if (k != j)
9:  219.53s             sum += temps[k][j]*b[k];
10:      
11: 320.21s     return boost::math::isfinite(sum) ? sum : 0;
13: 22.86s  }

有任何想法吗？

谢谢提醒伙计.以下是我从建议中得到的结果:

我发现切换到cbegin() …

我最近读到了关于NaNSSE算术运算中的值:

作用于两个而不是数字(NAN)参数的算术运算的结果是未定义的.因此,使用NAN参数的浮点运算将与相应汇编指令的预期行为不匹配.

资料来源:http://msdn.microsoft.com/en-us/library/x5c07e2a(v = vs.100).aspx

这是否意味着,添加两个__m128值可能会将a转换NaN为真实？

如果计算依赖于某个NaN值,我也需要最终结果NaN.有没有办法做到这一点？

我经常使用boost lexical_cast库将文本数据解析为数值。但是，在某些情况下，我只需要检查值是否为数字即可；我实际上不需要或不使用转换。

因此，我正在考虑编写一个简单的函数来测试字符串是否为双精度型：

template<typename T> 
bool is_double(const T& s)
{
  try 
  {
    boost::lexical_cast<double>(s); 
    return true;
  }
  catch (...) 
  {
    return false;
  }
}

我的问题是，由于我从未真正使用过该值，是否有任何优化的编译器会在此处放弃lexical_cast？

有没有更好的技术可以使用lexical_cast库执行输入检查？