小编Vin*_*ent的帖子

为什么STL容器定义访问器的const和非const版本？

定义const T& at(unsigned int i) const而T& at(unsigned int)不仅仅是非const版本有什么好处？

请考虑以下函数声明:

template<typename T> f(const T& x); // Version 1
template<typename T1, typename T2> f(const MyClass<T1, T2>& x); // Version 2

如果我f使用与之无关的类型调用,则将调用MyClass第一个版本.如果我f使用MyClass类型调用(无论模板参数类型是什么),那么将调用第二个版本.但现在,请考虑:

template<typename T1, typename T2, typename T3>
MyDerivedClass : public MyClass<T1, T2> {};

将为MyDerivedClass类型调用什么版本的函数？

考虑C++ 11中的以下函数:

template<class Function, class... Args, typename ReturnType = /*SOMETHING*/> 
inline ReturnType apply(Function&& f, const Args&... args);

我想ReturnType等于f(args...) 我必须写的结果类型而不是/*SOMETHING*/？

考虑以下函数,它在编译时根据参数类型计算积分或浮点模数:

template<typename T>
constexpr T modulo(const T x, const T y)
{
    return (std::is_floating_point<T>::value) ? (x < T() ? T(-1) : T(1))*((x < T() ? -x : x)-static_cast<long long int>((x/y < T() ? -x/y : x/y))*(y < T() ? -y : y))
    : (static_cast<typename std::conditional<std::is_floating_point<T>::value, int, T>::type>(x)
      %static_cast<typename std::conditional<std::is_floating_point<T>::value, int, T>::type>(y));
}

这个功能的身体能改善吗？(我需要为整数和浮点类型都有一个函数).

我一直听说确保最佳表现的良好做法是:

• 按值传递基本类型(int,double...)
• 通过const引用传递类

现在,在编译器下使用C++ 11和完全优化,当通过const引用传递基本类型时是否有开销？

进而,当T是int将以下功能:

template <typename T> inline void f(const T& x);

慢于:

template <typename T> inline void f(const T x);

请考虑以下代码:

#include <iostream>
#include <algorithm>
#include <numeric>

int main()
{
    const unsigned int size = 1000;
    std::vector<int> v(size);
    unsigned int cst = size/2;
    std::iota(v.begin(), v.end(), 0);
    std::random_shuffle(v.begin(), v.end());
    std::cout<<std::find_if(v.begin(), v.end(), [&cst](const int& i){return i == cst;})-v.begin()<<std::endl;
    std::cout<<std::find_if(v.begin(), v.end(), [=](const int& i){return i == cst;})-v.begin()<<std::endl;
    return 0;
}

此代码使用值填充向量,对其进行混洗,然后搜索指定值的索引(这只是一个示例来说明我的问题).cst可以通过引用或lambda函数中的值捕获此值.

我的问题:两个版本之间的性能是否存在差异,或者它们是否会被编译器以相同的方式进行优化？

通过引用传递常量基本类型和通过引用传递常量类是一个很好的规则(就像在普通函数中一样)？

自从CRTP几年前我发现以来,我在许多地方使用它来实现非常密集的面向计算的代码的编译时多态性.当人们在运行时关注通用性和最大性能时,以通用方式将成员函数"注入"到类中是很棒的.

我已经阅读/观看了几件事情concepts lite(我希望)是下一个C++标准的一部分.以更抽象和通用的方式设计函数是绝对美妙的,避免了SFINAE/std::enable_if我目前使用的可怕线条.

我没有测试g++实现概念的分支与它们一起玩,并以一种新的方式研究我喜欢的元编程方法.但也许有些人有.我的第一个想法是概念不会解决静态多态的问题,但由于这些事情可能严重依赖于技巧,我可能是错的.所以我的问题如下:概念lite能否以CRTP更方便的方式实现编译时多态(我们目前可以做到)？(欢迎使用代码示例).

在我的业余时间,我正在与我的一些朋友做一些逆向工程游戏,我想知道如何尽可能地防止asm可读性.我不想"阻止"逆向工程(毕竟它总是可能的),我只是想通过在汇编代码中混淆它们来阻止对函数/变量的简单理解.

例如,如果我在C++中声明了类似的函数:

void thisFunctionReverseAString(std::string& mystring);

我想确保无法获得名称thisFunctionReverseAString和mystring装配.是否有任何编译选项,这样做的g++还是clang++？

如何调整原子矢量的大小？

例如,以下代码无法编译:

#include <iostream>
#include <vector>
#include <atomic>

int main()
{
    std::vector<std::atomic<int>> v;
    v.resize(1000); // Problem here!
    v[0] = 1;
    return 0;
}

错误:

In file included from /usr/local/gcc-4.8.1/include/c++/4.8.1/vector:62:0,
                 from main.cpp:2:
/usr/local/gcc-4.8.1/include/c++/4.8.1/bits/stl_construct.h: In instantiation of ‘void std::_Construct(_T1*, _Args&& ...) [with _T1 = std::atomic<int>; _Args = {std::atomic<int>}]’:
/usr/local/gcc-4.8.1/include/c++/4.8.1/bits/stl_uninitialized.h:75:53:   required from ‘static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = std::move_iterator<std::atomic<int>*>; _ForwardIterator = std::atomic<int>*; bool _TrivialValueTypes = false]’
/usr/local/gcc-4.8.1/include/c++/4.8.1/bits/stl_uninitialized.h:117:41:   required from ‘_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = std::move_iterator<std::atomic<int>*>; _ForwardIterator = std::atomic<int>*]’
/usr/local/gcc-4.8.1/include/c++/4.8.1/bits/stl_uninitialized.h:258:63: …

显然,右移操作的行为:

a >> b

在C和C++中未定义b >= sizeof(a)*CHAR_BIT(而在正常情况下,由于右移而从左侧引入的"新位"等于零).

为什么这种未定义的行为比将结果设置为零更好b >= sizeof(a)*CHAR_BIT？