小编nap*_*con的帖子

如果我有std::map<X, Blah>,使用实例查找地图中匹配项目的最佳方法是Y什么？

假设信息Y足以唯一地找到X,但出于性能原因,我不想X通过复制Y值来创建实例.

我知道我可以创建一个公共基类或接口做到这一点X,并Y和制作该地图的关键,但有没有其他办法？例如,创建某种比较对象？

以下是示例代码:

class X
{
public:
    int id;
    int subId;
};

std::map<X, Details> detailsMap;

class Y
{
public:
    int getId();
    int getSubId();
    int someOtherUnrelatedThings1;
    int someOtherUnrelatedThings2;
};

现在,如果我有一个实例Y,原则上我应该能够在我的地图中找到匹配的项目,因为我可以得到一个id和subId一对.但我能做到这一点,而无需创建的实例X在和复制id和subId？

我正在尝试std::map通过使用boost传递地图内容来构造一个以参数为参数的对象map_list_of.

这给出了编译错误,但是,当我尝试使用带有a的常规函数​​执行相同操作时std::map,它编译得很好!

#include <map>
#include <boost/assign.hpp>

struct Blah
{
    Blah(std::map<int, int> data) {}
};

void makeBlah(std::map<int, int> data) {}

int main()
{
    Blah b(boost::assign::map_list_of(1, 2)(3, 4));    // Doesn't compile.

    makeBlah(boost::assign::map_list_of(1, 2)(3, 4));  // Compiles fine!
}

我得到的编译错误是:

error: call of overloaded ‘Blah(boost::assign_detail::generic_list<std::pair<int, int> >&)’ is ambiguous
note: candidates are: Blah::Blah(std::map<int, int, std::less<int>, std::allocator<std::pair<const int, int> > >)
note:                 Blah::Blah(const Blah&)

什么是歧义,为什么它不会影响常规的functoin makeBlah,据我所知,它与Blah构造函数具有相同的签名？

有没有更好的方法来实现这一点,而不是制作一个makeBlah将构造函数作为对象的函数Blah,因为它看起来像我将要做的那样？

(顺便说一下,我在单元测试中这样做,map_list_of用于使测试输入数据创建更具可读性)

如果我有一个find有时无法找到所需内容的函数,我倾向于使该函数返回一个指针,使得a nullptr指示找不到该东西.

例如

Student* SomeClass::findStudent(/** some criteria. */)

如果Student存在,它将返回指向找到的Student对象的指针,否则它将返回nullptr.

我也看到了boost::optional为这个目的而提倡的.例如,当你想要实现一个可以返回"nothing"的函数时,何时使用boost :: optional以及何时使用std :: unique_ptr？

我的问题是,在这种情况下,没有返回指针是最佳解决方案.即,有可能找不到查询的项目,在这种情况下返回nullptr是一个完美的解决方案.使用类似boost::optional(或任何其他类似解决方案)的东西有什么好处？

请注意,在我的示例中,findStudent只会返回指向由其拥有的对象的指针SomeClass.

我想在我的测试夹具类中添加一个实用函数，该函数将返回具有特定期望/操作集的模拟。

例如：

class MockListener: public Listener\n{\n    // Google mock method.\n};\n\nclass MyTest: public testing::Test\n{\npublic:\n    MockListener getSpecialListener()\n    {\n        MockListener special;\n        EXPECT_CALL(special, /** Some special behaviour e.g. WillRepeatedly(Invoke( */ );\n        return special;\n    }\n};\n\nTEST_F(MyTest, MyTestUsingSpecialListener)\n{\n    MockListener special = getSpecialListener();\n\n    // Do something with special.\n}\n

不幸的是我得到：

error: use of deleted function \xe2\x80\x98MockListener ::MockListener (MockListener &&)\xe2\x80\x99\n

所以我认为模拟不能被复制？为什么，如果是的话，是否有另一种优雅的方式来获得一个函数来制造一个已经设置了期望/动作的现成的模拟？

显然我可以让 getSpecialListener 返回一个 MockListener& ，但是这样它就不必要成为 MyTest 的成员，并且因为只有一些测试使用该特定的模拟（并且如果测试正在使用它，我应该只填充模拟行为）它会不太干净。

简而言之,是否有可能让C++强制一个方法的调用者放一个try ... catch块？

(澄清一下:我并不一定意味着直接调用者,我的意思是强迫它被捕获到某个地方.而且,我正在谈论在编译时强制执行.)

长:

我已经读过,不建议使用异常规范,并且无论如何它都无法正常工作(http://4thmouse.com/mystuff/articles/UsingExceptionsEffectively.html)

但普遍的共识似乎倾向于使用异常来返回写入返回错误代码的方法的用户的错误.

所以,如果我正在写一个库,那么什么是阻止用户调用我的方法而不放任何try ... catch块,然后当我的代码抛出异常时让他的程序崩溃？

(要明确的是,我只需要在用户堆栈中的某处捕获异常,不一定在立即调用代码中,并且如果不是这样,编译器会抱怨.)

在C++中,我可以动态创建一个接口的实现(理想情况下绑定本地范围的变量.)不确定如何更好地解释它,所以我将放下我希望代码看起来像(大致):

// Given the following:

class Visitor
{
    virtual void visit(const Data& data) = 0;
}

class DataStore
{
    void visitData(Visitor& visitor) { /** Invokes visitor with each item of data. */ }
}

// Imagine one would write something like:

void inSomeFunction(DataStore& store)
{
    std::string myName = "bob";

    class MyVisitor: public Visitor
    {
    public:
        MyVisitor(const std::string& p): person(p);
        virtual void visit(const Data& data) override
        {
            std::cout << person << " is visiting " << data << std::endl;
        }
    private: …

我有一个接口类说:

class MyInterface
{
public:
    virtual int doThing(int x, int y, int z) = 0;
};

我想编写一个模拟实现,以便在我的测试中使用.例如,传统上,不使用谷歌模拟,我会写:

class MyMock : public MyInterface
{
public:
    virtual int doThing(int x, int y, int z)
    {
        if (x == 1)
            return y + z;
        else
            return y - z;
    }
};

我将如何在谷歌模拟中这样做.请注意,我不想(好的,我不需要)设置关于如何调用这个模拟的期望.我只是用它来测试别的东西.

你会怎么做(以及最清晰的方式)？我发现google mocks文档有点过于简洁,无法解决这个问题.

我有一个元素的向量.我想使用匹配特定条件的此向量元素填充集合.我可以使用一行,或以比下面更简洁的方式执行此操作吗？

// given vector<int> v

set<int> s;
for (const int& i : v)
{
    if (/* some condition on i*/)
        s.insert(i);
}

例如,以下内容:

// given vector<int> v

set<int> s;
s.insert(v.filter(/* lambda here*/));

不言而喻,出于性能原因,v.filter方法应返回迭代器,而不是单独的填充向量.

我有一种情况，我想检查是否使用参数 X 调用了模拟对象方法，但测试仅在调用模拟后才能访问 X ，因此我无法事先设置 EXPECT_CALL。

例如

// The class I'm testing.
class Maker
{
    void register(Listener& lis);
    Obj& make()
    {
        // make new Obj o
        // call created(o) on registered Listener  
        // return o
    }
}

class Listener
{
    virtual void created(Obj& o) = 0;
}

// The test
Listener lis;
Maker maker;
maker.register(lis);

Obj& o = maker.make();

// Check that lis was invoked using param o...how?

我可以用谷歌模拟来做到这一点吗？使用谷歌模拟执行此操作的最优雅/可读的方式是什么？

显然我可以制作自己的 MockListener 来记录调用参数，而不是使用谷歌模拟。但我希望 google mocks 能够提供一种更易读的机制，类似于 EXPECT_CALL。

什么是编程中的monad,可以解释为:

1. 您不需要了解Haskell的任何先验知识.
2. 您可以继续使用或构建更多主流编程语言(如C++/Java/Scala)中的概念.

基本上,我在网上学习中遇到过这个术语.例如,这篇Java 8 Stream教程提到了monads(http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/).所以我想以有用的方式理解基本概念.(与像"想象编程为橙色,然后monads将是葡萄柚......"这样的愚蠢方式相反.)

但是,每个monad教程似乎都需要先前的知识(或试图在运行中教你)Haskell或Haskell语法.