将一种类型的向量分配给另一种类型的向量

发布于 2024-08-28 23:35:19 字数 148 浏览 3 评论 0原文

我有一个“事件”课程。由于处理日期的方式,我们需要将此类包装在“UIEvent”类中,该类保存事件以及另一种格式的事件日期。

允许从事件到 UIEvent 来回转换的最佳方式是什么?我认为重载 UIEvent 的赋值或复制构造函数来接受事件(反之亦然)可能是最好的。

I have an "Event" class. Due to the way dates are handled, we need to wrap this class in a "UIEvent" class, which holds the Event, and the date of the Event in another format.

What is the best way of allowing conversion from Event to UIEvent and back? I thought overloading the assignment or copy constructor of UIEvent to accept Events (and vice versa)might be best.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(2

扛起拖把扫天下 2024-09-04 23:35:19

我能想到两个简单的选择。

第一个选项是您描述的选项:创建一个采用另一种类型的对象的构造函数:

struct UIEvent
{
    UIEvent(const Event&);
};

并使用 std::copy 将元素从一种类型的向量复制到另一种类型的向量:

std::vector<Event> eventVector;
std::vector<UIEvent> uiEventVector;

std::copy(eventVector.begin(), eventVector.end(), 
          std::back_inserter(uiEventVector));

第二个选择是编写一个非成员转换函数:

UIEvent EventToUIEvent(const Event&);

并使用 std::transform :

std::transform(eventVector.begin(), eventVector.end(), 
               std::back_inserter(uiEventVector), &EventToUIEvent);

这样做的优点是类之间的直接耦合较少。另一方面,有时类无论如何都是自然耦合的,在这种情况下,第一个选项可能同样有意义并且可能不那么麻烦。

There are two simple options that I can think of.

The first option would be the one you describe: create a constructor that takes an object of the other type:

struct UIEvent
{
    UIEvent(const Event&);
};

and use std::copy to copy elements from a vector of one type to a vector of the other:

std::vector<Event> eventVector;
std::vector<UIEvent> uiEventVector;

std::copy(eventVector.begin(), eventVector.end(), 
          std::back_inserter(uiEventVector));

The second option would be to write a non-member conversion function:

UIEvent EventToUIEvent(const Event&);

and use std::transform:

std::transform(eventVector.begin(), eventVector.end(), 
               std::back_inserter(uiEventVector), &EventToUIEvent);

The advantage of doing it this way is that there is less direct coupling between the classes. On the other hand, sometimes classes are naturally coupled anyway, in which case the first option might make just as much sense and could be less cumbersome.

一杯敬自由 2024-09-04 23:35:19

如果您可以将 Event 转换为 UIEvent(例如,如果 UIEvent 有一个接受 Event 的构造函数作为参数),那么以下将把一个向量分配给另一个向量:

uievent_vector.reserve(event_vector.size());
uievent_vector.assign(event_vector.begin(), event_vector.end());

当然,如果转换有效,另一种方式也可以工作。

或者,您可以使用 std::copy() 来获得相同的效果。如果您无法在类接口内以一种方式进行转换,则编写一个进行转换的函数,然后使用 std::transform() :

struct to_uievent {
    UIEvent operator()(const Event& e) {
        // ...
    }
};

// ...
    std::transform(event_vector.begin(), event_vector.end(),
                   back_inserter(uievent_vector),
                   to_uievent());

当然,您可以添加任意多个在上面的函数对象中按照您的意愿重载 operator()() ,以便您可以使用相同的函数对象进行其他转换。

If you can convert an Event to a UIEvent (for example, if UIEvent has a constructor that takes an Event as parameter) then the following will assign one vector onto another:

uievent_vector.reserve(event_vector.size());
uievent_vector.assign(event_vector.begin(), event_vector.end());

Naturally the other way around would work as well if that conversion works.

Alternatively you can use std::copy() to get the same effect. If you can't make the conversion in one way inside the class interface, then write a function that makes the conversion and then use std::transform():

struct to_uievent {
    UIEvent operator()(const Event& e) {
        // ...
    }
};

// ...
    std::transform(event_vector.begin(), event_vector.end(),
                   back_inserter(uievent_vector),
                   to_uievent());

You can, of course, add as many overloads as you wish of operator()() in the above function object so you can use that same function object for other conversions.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文