小编pet*_*555的帖子

我是否应该包括每个标题,即使之前包括它？或者我可以尽可能地避免它？例如.如果我使用std::string和std::vector在某些文件中.如果<string>包含<vector>我应该只包括<string>或<string>和<vector>？

我需要编写简单的http客户端.为我的班级进行单元测试可能会很棒.但我不知道如何写出适当且可测试的课程.

例如,我有一个像这样的客户端:

class HTTPClient
{
public:
     HTTPCLient(const std::string& host, const std::string& port): session(host, port) {}

     void send()
     {
         session.sendRequest(someRequest);
         Response response = session.receiveResponse();
         // ...
     }

private:
    SomeLibrary::ClientSession session;
};

如何测试send方法(我真的发送我想要的东西)？我无法嘲笑它.我可以 在构造函数中编写HTTPClient接收SomeLibrary::ClientSession对象(在测试中我会传递模拟)但它是好的设计吗？我认为会话等的实现方式应该隐藏在我的课堂中.

你有什么主意吗？

CppCheck找到了一些调查结果:"变量'x'的范围可以减少".

如果我遇到这种情况怎么办:

int x;
for (int i = 0; i != 10; ++i)
{
    x = someFunction();

    // ... I use x variable here
}

我认为我的代码没问题.你怎么看？它会变成这样的东西吗？

for (int i = 0; i != 10; ++i)
{
    int x = someFunction();

    // ... I use x variable here
}

在第二个代码中,为所有迭代定义了变量x ...不是不好(不是最佳的),我猜...

我尝试从图像中去除噪音。我在图像中有一些黑色像素组。我使用 cv::findContours 和 cv::boundingRect。我用白色填充小矩形（小矩形是图像中的噪声）。但是这种方法也找到了我的白色轮廓（例如黑色圆圈的中间）。如何找到黑色像素的计数？有什么简单的解决办法吗？

我有这样的代码:

int function()
{
    std::vector<std::future<int>> futures;
    for (const auto& elem : elements)
    {
        futures.push_back(std::async(&MyClass::foo, myClass, elem);
    }
    for (auto& f : futures)
    {
        const int x = f.get();
        if (x != 0)
            return x;
    }
}

当有未完成的异步调用时,我可以从函数返回吗？我只对一个非零值感兴趣.我应该等到所有异步调用完成吗？这段代码安全吗？

这段代码安全吗？

class C : public std::enable_shared_from_this<C> {
    void start() {
             boost::asio::async_write(socket_, boost::asio::buffer(message_), 
             std::bind(&tcp_connection::handle_write, shared_from_this(),
             _1, _2));
    };
    // ...
};

class D {
    void start()
    {
         std::shared_ptr<C> cptr = std::make_shared<C>(); // (1)
         cptr->start();
    } // (2)
};

如果消息很长,则async_write操作可能需要很长时间.

在点(1)处只有一个shared_ptr指向C对象.start()被称为,start()完成和在(2)变量cptr超出范围并被销毁.

当async_write完成写操作,回调被调用; 这会导致崩溃,因为shared_from_this()尝试创建shared_ptr一个不存在的对象.

这是对正确的描述吗？

我想优化我的代码.我有一个具有shared_ptr数据成员的类.在这个类的一些方法中,我创建了需要使用这个成员的对象(只是为了从shared_ptr指向的对象获取信息).我知道这些创建对象的生命周期低于我的主类.如何传递这个指针？我认为另一个shared_ptrs是不必要的(因为我保证对象将存在).那么应该得到我创建的类？他们应该得到原始指针吗？weak_ptr的？或者最好的解决方案是获取shared_ptr(并递增其引用计数器)？什么是最标准的解决方案？

我已经模拟了虚方法返回istream&.我想在测试用例中使用它.如何返回一些价值？

问题istream是不可复制.

我尝试这样的事情:

TEST(x, y)
{
     MockClass mock;
     std::istringstream str("Some text");

     EXPECT_CALL(mock, m(_)).WillOnce(Return(str)); // m method returns std::istream&

     sut.callMethod();
}

我需要创造std::map<cv::Point, double>.cv::Point是一种来自OpenCV库的点.它有以下字段:x和y.

cv::Point<当然没有操作员.您是否知道如何定义它以获得对元素的最佳访问std::map？

换一种说法.我有例如20000点.我需要快速访问每一点.

例如:

std::map<cv::Point, double> myMap;

Point p(10, 234);
int value = 777;
myMap[p] = value; // I need this operation quite fast so I decided to use std::map

但是cv :: Point没有<运算符.我可以准备<运算符(它只比较x坐标):

bool operator<(const cv::Point a, const cv::Point b)
{
    return a.x < a.x;
}

但我想这不是好运营商.许多点具有相同的x值.

在这种情况下如何准备有效的操作员？

我有这样的课:

template <typename T>
class C
{
public:
    C(T t): t{t} {}
    void publicMethodA() { privateMethodA(); }
    void publicMethodB() {}
    void publicMethodC() {}
    // ...

private:
    void privateMethodA() { t.call(); /* only one place that uses t member */ }
    void privateMethodB() {}
    // ...

    T t;
};

在这个例子中,我只需要t在一个地方(in privateMethodA)中的模板字段,它强制我在头文件中定义每个方法(但它们不使用t成员).我怎么能避免这个？你有什么想法？