小编rel*_*xxx的帖子

有时,if语句可能相当复杂或冗长,因此为了便于阅读,最好在之前提取复杂的调用if.

例如:

if (SomeComplicatedFunctionCall() || OtherComplicatedFunctionCall())
{
    // do stuff
}

进入这个

bool b1 = SomeComplicatedFunctionCall();
bool b2 = OtherComplicatedFunctionCall();

if (b1 || b2)
{
    //do stuff
}

(提供示例并不是那么糟糕,它仅用于说明...想象其他具有多个参数的调用等)

但是通过这种提取,我失去了短路评估(SCE).

1. 我每次真的失去了SCE吗？是否存在允许编译器"优化"并仍提供SCE的情况？
2. 有没有办法保持第二个片段的可读性提高而不会失去SCE？

我有类Base和类Derived_1,Derived_2...我需要派生类来获取id.那些id用于进一步查找等,因此需要是连续的(不只是一些随机数).因为派生类是由用户创建的,所以id不能是其成员Derived_N.所以我想出了DerivedType课.

class DerivedType
{
    static unsigned id;
    unsigned m_id;
public:
    DerivedType() : m_id(id++) {  }
}

现在我想在Derived_N和之间创建一个映射DerivedType.每当Derived_N创建,这个映射如下,如果DerivedType针对特定Derived_N已经存在,并返回,否则创建的新地图和商店.

实际的问题:有没有办法使用std::map与数据类型作为关键的地图吗？我不怕任何模板 - 元程序解决方案.或者有优雅的方式如何实现我的目标？

编辑日期类型 - >数据类型,我的意思是像ClassType,对不起:)

我想用它像:

Derived_5 d;
DerivedType dt = getType(d); //Derived_5 is looked up in map, returning particular DerivedType
dt.getId();

Derived_N(具有相同的'N')的每个实例应该具有与DerivedType相同的id

EDIT2 - 我的答案 我找到了解决问题的更好方法......就像这样:

atomic_counter s_nextEventClassID;

typedef int cid_t;

template<class EventClass> …

我想找到点,它具有较小的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 …

我在*.hpp文件中编写模板声明,并在*.hpp文件中链接*.inl文件中的"定义"

像这样:

//*.hpp
template <typename T1, typename T2>
class SomeClass
{
public:
    void someMethod();
};

//*.inl
template <typename T1, typename T2>
void SomeClass<T1, T2>::someMethod()
{
}

但如何在*.inl文件中的模板类中编写额外的模板化方法？

//*.hpp
template <typename T1, typename T2>
class SomeClass
{
public:
    void someMethod();

    template <typename E>
    void extraTypedMethod(E & e);
};

//*.inl
template <typename T1, typename T2>
void SomeClass<T1, T2>::someMethod()
{
}

//how can I here define extraTypedmethod?

我知道散列无限数量的字符串到32b int必须生成碰撞,但我期望从散列函数中得到一些不错的分布.

这两个字符串具有相同的哈希值是不是很奇怪？

size_t hash0 = std::hash<std::string>()("generated_id_0");
size_t hash1 = std::hash<std::string>()("generated_id_1");
//hash0 == hash1

我知道我可以使用boost::hash<std::string>或其他人,但我想知道什么是错的std::hash.我用错了吗？我不应该以某种方式"播种"它吗？

你更倾向哪个？(当然getSize不做任何复杂的计数,只返回成员值)

void method1(Object & o)
{
    int size = o.getSize();

    someAction(size);
    someOtherAction(size);
}

要么

void method2(Object & o)
{
    someAction(o.getSize());
    someOtherAction(o.getSize());
}

我知道我可以测量哪一个更快但我想要一些评论......不只是执行时间相关...例如.如果你更喜欢method2,你最多使用o.getSize多少次,你使用method1方式的数字是多少？任何最佳做法？(想象甚至不同类型然后int)TY

如果struct/class有一些填充,是否有一种方法(trait左右)可以检测？

我不需要跨平台或标准化解决方案,我需要它用于MSVC2013.

我可以检查一下

namespace A
{
    struct Foo
    {
        int a;
        bool b;
    };
}

#pragma pack(push, 1)
namespace B
{
    struct Foo
    {
        int a;
        bool b;
    };
}
#pragma pack(pop)

static const bool has_padding = sizeof(A::Foo) != sizeof(B::Foo);

但是C++不允许(据我所知)生成这种非侵入性(不触及现有的结构)

理想情况下,我希望得到这样的工作

template <typename T>
struct has_padding_impl
{
    typedef __declspec(align(1)) struct T AllignedT;
};

template <typename T>
struct has_padding : typename std::conditional<sizeof(typename has_padding_impl<T>::AllignedT) == sizeof(T),
                                               std::false_type,
                                               std::true_type>::type{};

编辑 - 为什么我需要这个？

我正在使用现有的序列化系统,它存储一些结构只需要void*它们(在通用函数内)和存储sizeof(T)字节数......这样的二进制文件在我们所针对的平台上是不可移植的,因为使用了不同的编译器,所以那里不保证如何插入填充.如果我可以静态检测所有T带有填充的结构,我可以强制用户手动插入填充(一些控制填充,例如不仅仅是随机垃圾),因此没有"随机"填充.另一个优点是,当我对两个相同scenerio的保存文件进行差异化时,它们看起来是一样的.

编辑2 我想的越多,我就越意识到我需要跨平台的解决方案.我们主要在msvc2013上开发,但我们的应用程序最终在msvc2012和clang中构建.但是,如果我在msvc2013中检测到并删除了所有编译器生成的填充,则无法保证其他编译器不插入填充...(因此msvc2013检测不够)

一旦我的类没有定义析构函数,下面的代码给出 warning C4189: 'f' : local variable is initialized but not referenced

(f->~Fred()未被识别为引用f)

这是一个错误,还是这个标准行为？

struct Fred
{
    int a, b;
    //~Fred(){}
};

int main()
{
    char memory[sizeof(Fred)];

    void * place = memory;

    Fred* f = new(place)Fred();

    f->~Fred();
}

这段代码当然没有意义(它是最小的工作样本),但是在编写池分配器并使用它时,我在实际场景中得到了这个错误

template <typename T>
void CallDestructor(T * t)
{
    t->~T();
}

我使用visual studio 2013警告级别4我在一些在线编译器上测试它而没有警告,但我不确定他们的警告级别是什么

我正在通过wxWidgets开发GUI应用程序.它有两部分:GUI部分和"逻辑"部分.我希望Logic部分完全独立于wxWidgets.但GUI中的一个组件返回wxVariant,我需要在逻辑部分使用它.

所以我正在寻找一种方法将wxVariant"转换"为boost :: variant

wxVariant的工作原理如下:

wxVariant v("37");
int i = v.GetInteger(); //i==37

所以我在想类似的东西

string s = methodReturningWxVariant().GetString();
boost::variant bV(s);

//later in code e.g
bV.GetInt();
bV.GetBool();

可以像这样使用boost :: Variant(或boost :: Any)吗？

我一直在阅读关于>>嵌套模板和>>移位运算符的结束...

现在我已经在我的MSVS2010中尝试过了,没有问题.

std::map<int, std::pair<int, int>> m;

这段代码正是我想要的(对的映射),但我应该得到一些错误 >>

这些天编译器更聪明？