2

参加以下课程：

template <typename TPayload>
class Message
{
    public:
        Message(const TPayload& payload)
             : m_header(sizeof(TPayload)),
               m_payload(payload) {}

    private:
        const Header   m_header;
        const TPayload m_payload;
};

每当我构造一条消息时，我都必须创建一个 TPayload（参数有效负载），将其复制到 m_payload 中，然后销毁有效负载。现在考虑这可以每秒完成 100'000 次，我认为这是一种浪费的努力。

我的问题是，我可以强制 m_payload 的就地构造来避免临时有效负载吗？

我正在考虑的一种可能的解决方案是多次重载结构，如下所示，但老实说，我怀疑是否有很多节省。

template <typename TPayload>
class Message
{
    public:
        template <typename A>
        Message(const A& a)
             : m_header(sizeof(TPayload)),
               m_payload(a) {}

        template <typename A, typename B>
        Message(const A& a, const B& b)
             : m_header(sizeof(TPayload)),
               m_payload(a, b) {}

    private:
        const Header   m_header;
        const TPayload m_payload;
};
4

2 回答 2

3

您正在寻找的是转发给构造函数的构造函数Message参数Message::m_payload。

这可以在 C++11 中巧妙地完成（使用可变参数模板和std::forward，如在std::vector<>::emplace_back()和许多其他函数中使用的那样）或在 C++03 中使用几个重载，正如您开始编写和使用的那样in boost::make_shared<>

例如：

#include <iostream>
#include <string>
#include <utility>
typedef size_t Header;
template <typename TPayload>
class Message
{
    public:
        template <typename ...Args>
        Message(Args&&... args)
             : m_header(sizeof(TPayload)),
               m_payload(std::forward<Args>(args)...)
               {}
        void show_payload() const
        {
                std::cout << m_payload << '\n';
        }
    private:
        const Header   m_header;
        const TPayload m_payload;
};

int main()
{
     Message<std::string> test(10, 'a');
     test.show_payload();

     Message<double> test2(3.14);
     test2.show_payload();
}

测试运行：https ://ideone.com/J1JnZ

于 2011-04-19T15:57:17.403 回答
2

同样在 C++11 中，您可以按值接受参数，然后移动构造它：

Message(TPayload payload)
    :m_header(sizeof(TPayload)),
     m_payload(std::move(payload)) {}

只要确保 TPayload 有一个正确定义且有用的移动构造函数，否则这不会有多大好处。

于 2011-04-19T16:08:40.817 回答