What's the difference between these two narrowing conversions?

Here is a code snippet with two lines performing narrowing conversions. Why does one of them compile fine, but the other one doesn't? They are doing the same thing as far as narrowing conversions go.

This is a contrived example. I know I could have just used nums.size() to get the size. This is not the point of the question.

std::vector<int> func(std::vector<int>& nums) {
    int works_fine = nums.end() - nums.begin(); // this compiles
    return std::vector<int>({ nums.end() - nums.begin() }); // this does not compile
}

The line with the return statement gives this warning:

warning: narrowing conversion of '__gnu_cxx::operator-<int*, std::vector<int> >((& nums)->std::vector<int>::end(), (& nums)->std::vector<int>::begin())' from '__gnu_cxx::__normal_iterator<int*, std::vector<int> >::difference_type' {aka 'long long int'} to 'int' [-Wnarrowing]

There is nothing wrong with how you obtain the index of the end iterator.

However, there is a problem with your std::vector initialization. There are two relevant constructors. One that accepts a single argument for a parameter of type std::vector<int>::size_type (usually std::size_t) and one that has a single parameter of type std::initializer_list<int>.

The issue is thatstd::initializer_list's are special in overload resolution and always preferred over conversion to other parameter types in list-initialization, i.e. when the argument is a braced-init-list (i.e. not an expression but instead a starting with a {).

So the constructor chosen here is the one that takes the std::initializer_list<int> and that initializes the vector with the elements of that list.

Then the problem is that to construct the int element of the std::initializer_list<int> you must convert nums.end() - nums.begin() to type int. The type of nums.end() - nums.begin() is std::vector<int>::difference_type (usually std::ptrdiff_t), which is likely to be wider than int, so that this is a narrowing conversion.

And narrowing conversions are not permitted in list-initialization. (GCC is already unusually permissive by only providing a warning instead of failing to compile it. Other compilers are not that permissive, but both behaviors are conforming.)

According to your comments this really is the constructor that you want to use, so:

To make it compile properly you need to explicitly cast nums.end() - nums.begin() to int:

std::vector<int>({static_cast<int>(nums.end() - nums.begin())});

or you can use an equivalent constructor that doesn't use list-initialization:

std::vector<int>(1, nums.end() - nums.begin());

In either case, the warning/error is there for a good reason: What do you want to happen if the index is larger than int can hold? Both solutions given above ignore this and will simply store an unintended value in the vector. To do this properly you need to rethink the int element type for the vector. It should probably be std::ptrdiff_t or even better std::vector<int>::difference_type. Alternatively you can add an out-of-range check and e.g. throw an exception or do whatever is sensible to your use case.