小编Vin*_*ent的帖子

我不是自定义分配器的用户,但我想知道是否可以使用自定义分配器来重新定义增长策略.例如,在大多数实现中,a std::vector几何增长.是否有可能为算术增长改变此策略,例如每次需要重新分配时添加10个元素.如果答案是肯定的,那该怎么办呢？

请考虑以下代码:

// Classic version
template <class It>
It f(It first, It last)
{
    using value_type = It::value_type;
    auto lambda = [](value_type x){return x > 10 && x < 100;};
    return std::find_if(first, last, lambda);
}

// Static version
template <class It>
It f(It first, It last)
{
    using value_type = It::value_type;
    static auto lambda = [](value_type x){return x > 10 && x < 100;};
    return std::find_if(first, last, lambda);
}

这两者之间有任何性能差异吗？lambda函数的构造时间是多少？静态版本在性能方面是否更好,因为lambda只构造一次？

考虑一个64位无符号整数数组,如:

std::array<unsigned long long int, 20> a;

什么是最快的方法,包括使用英特尔或编译器内在函数(这个或那个)(使用g ++ 5.3)来执行全局位移(右或左),因为这个数组是一个单位整数？

请考虑以下代码:

template <class /* Weird Hack Here */>
struct object
{
    constexpr object(int value, /* Other Weird Hack */) noexcept;
};

int main() 
{
    object foo(1);
    object bar(1);
}

是否有可能在C++ 17中使用奇怪的技巧来拥有foo和bar成为不同的类型？

C++ 标准定义well-formed programs为

根据语法规则、可诊断语义规则和一定义规则构造的C++程序

我想知道是否所有格式良好的程序都能编译（如果不是这样，什么类型的错误会导致格式良好的程序和可编译问题之间存在差异）。例如，包含歧义错误的程序会被认为是格式良好的吗？

可能重复:
C++虚函数表内存开销

我很高兴看到:http://www.parashift.com/c++-faq-lite/virtual-functions.html,我想知道由于虚拟性导致的内存开销是多少.我正在为超级计算机编写优化代码,我必须在可读代码和内存消耗之间找到良好的平衡.

为了理解它是如何工作的,以下类的内存开销是:

class AbstractA {/* SOMETHING */};
class AbstractB {/* SOMETHING */};
class A : public AbstractA {/* SOMETHING */};
class B : public AbstractB {/* SOMETHING */};
class A2 : public A {/* SOMETHING */};
class B2 : public B {/* SOMETHING */};
class AbstractAB : public AbstractA, public AbstractB {/* SOMETHING */};
class AbstractAB2 : public AbstractAB {/* SOMETHING */};

假设我每个类有10亿个对象,我不得不打扰非静态内存消耗.那么对于每种对象类型多少钱？(如果AbstractA的每个虚方法都会为"A"类型的每个对象创建一个指针,我就死...)

我的C++代码中有一个奇怪的元函数行为,我想了解原因.

#include <iostream>
#include <cmath>

inline double f(double x, double y)
{
    std::cout<<"Marker"<<std::endl;
    return sqrt(x*y);
}

template <int N, class T> inline T metaPow(T x)
{
    return ((N > 0) ? (x*metaPow<((N > 0) ? (N-1) : (0))>(x)) : (1.));
}


int main()
{
    double x;
    double y;
    std::cin>>x;
    std::cin>>y;
    std::cout<<metaPow<5>(f(x, y))<<std::endl;
    return 0;
}

我预计这条线metaPow<5>(f(x, y))相当于f(x, y)*f(x, y)*f(x, y)*f(x, y)*f(x, y)*1..但如果是的话,它会打印Marker出f函数中" "行的五倍.

奇怪的是,我最终得到了很好的结果(例如181.019for x = 2和y = …

在一个项目中,我有以下问题:

我有一个非常简单的继承方案(我需要继承而不是组合):

班级基地

- >类DerivedA

- >类DerivedB

- >类DerivedC

A,B和C来自Base,这就是全部.所以现在我有两个选择:

公共继承与虚拟

没有虚拟的私有继承

出于某些优化原因(我需要很多内联)我不想要虚拟化......我不想要私有继承.我认为唯一的选择是CRTP.但是基类有300个功能,在其中实现CRTP将是一个真正的痛苦.

所以我想知道以下解决方案是否有效:我只在基类的析构函数中使用CRTP:

template<class TCRTP> class Base
{
    ~Base() {delete static_cast<TCRTP*>(this);}
}

其中TCRTP将是DerivedA,B或C,我做公共继承.它完全没问题,还是有问题？

非常感谢你.

我的问题如下.我想创建一个新的小部件,它是一个QTableWidget+ a QMenuBar(具有特定的配置QTableWidget).目前,我已经创建了一个MyWidget,它派生自QWidget并包含一个QTableWidget+ a QMenuBar.但有可能通过推导做同样的事情MyWidget,从QTableWidget和QMenuBar？如果有可能构造函数是什么样的？

在混合CRTP,可变参数模板,元编程和运算符重载的类中,我想比较两个可变的unsigned int模板参数,以便进行一些静态断言.我认为辅助结构将是一个很好的方法,但我不知道如何做到这一点.我想到了一些形式:

template<unsigned int... TDIM, unsigned int... TDIM0> struct HelperCheckDimensions
{
    static const bool ok = /* SOMETHING */
};

其中TDIM和TDIM0是两个参数,我想比较.它允许我输入:

static_assert(HelperCheckDimensions<TDIM..., TDIM0...>::ok, "ERROR : Dimensions are different !");

我希望结果只有在sizeof...(TDIM)==sizeof...(TDIM0)AND 时才为真TDIM[0] == TDIM0[0], TDIM[1] == TDIM0[1], ..., TDIM[n] == TDIM0[n].

怎么做 ？

非常感谢你.