C ++ emplace_back与嵌套对象优化

Question

I was slightly confused about behavior of emplace_back. Let's have a look.

struct innerObject
{
    innerObject(int );
};

class outterObject
{
    innerObject member;
public:
    outterObject(innerObject member);
};

int main()
{
    std::vector<outterObject> v1;
    v1.emplace_back(5);
}

So in this case we could pass integer and it works.

What about constructor if innerObject needed two int s to construct from instead of just one? Neither v1.emplace_back(5,5) nor v1.emplace_back({5,5}) nor any other combination which I tried works. Is it somehow possible? Is there any better option to make such things? (optimized)

Answer 1

The only way to avoid any kind of copy/move is for the outer type to opt-in to that sort of operation by providing a generalized constructor:

template <typename A0, typename... Args,
    std::enable_if_t<
        !std::is_same_v<std::decay_t<A0>, outterObject> &&
        std::is_constructible_v<outterObject, A0, Args...>
        , int> = 0>
outterObject(A0&& a0, Args&&... args)
    : member(std::forward<A0>(a0), std::forward<Args>(args)...)
{ }

This would let you write v1.emplace_back(10, 20) if innerObject were constructible from 2 int s.

If that seems like too much overkill, you can always just do v1.push_back({{10, 20}}) . Note that push_back() , unlike emplace_back() , doesn't deduce its argument type - it's just T const& or T&& . This allows you to use {} s.

Answer 2

The reason it works for one argument is that the single int constructor for your innerObject class acts as a converting constructor. In other words outterObject constructor takes an innerObject object, and due to the converting constructor rules, it converts the single int argument to an innerObject.

A constructor that is not declared with the specifier explicit and which can be called with a single parameter (until C++11) is called a converting constructor. Link

Converting constructors only work for single argument constructors.

If you write explicit before the innerObject constructor taking a single int, you'll see it won't compile, because "explicit" keyword disallows the int argument to automatically create an innerObject to pass to the outerObject constructor:

  v1.emplace_back(5); // v1 is a vector of outerObject.

The only reason this works is that the 5 argument is converted into an innerObject via its non-explicit constructor taking an int. This converting constructor behaviour only works for single argument constructors.

If you want you can add the two argument constructor to innerObject:

innerObject(int x, int y)
    {
        std::cout << "constructor innerObject" << std::endl;
    }

And then:

v1.emplace_back(innerObject(5, 6));

Answer 3

You can simply construct inner object and than emplace_back:

v1.emplace_back(innerObject{10, 20});

Alternatively, you can add a constructor for outerObject which accepts two arguments and than calls innerObject constructor. In this case you would call it this way:

v1.emplace_back(10, 20);