struct MovableNonCopyable
{
  MovableNonCopyable() = default;
  MovableNonCopyable(MovableNonCopyable&&) = default;
};
// . . . 
std::vector<MovableNonCopyable> v { MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable() };
// error: use of deleted function ‘constexpr MovableNonCopyable::MovableNonCopyable(const MovableNonCopyable&)’

R>struct MovableNonCopyable
R>{
R>  MovableNonCopyable() = default;
R>  MovableNonCopyable(MovableNonCopyable&&) = default;
R>};
R>// . . . 
R>std::vector<MovableNonCopyable> v { MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable() };
R>// error: use of deleted function ‘constexpr MovableNonCopyable::MovableNonCopyable(const MovableNonCopyable&)’
R>

T must meet the requirements of CopyAssignable and CopyConstructible.

MovableNonCopyable v[] = { MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable() };

The requirements that are imposed on the elements depend on the actual operations performed on the container. Generally, it is required that element type is a complete type and meets the requirements of Erasable, but many member functions impose stricter requirements.

An object of type std::initializer_list<T> is a lightweight proxy object that provides access to an array of objects of type const T.

MovableNonCopyable v[] = { MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable() };

struct MovableNonCopyable
{
  MovableNonCopyable() = default;
  MovableNonCopyable(MovableNonCopyable&&) = default;
};
// . . . 
std::vector<MovableNonCopyable> v; //{ MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable() };

MovableNonCopyable t;
v.emplace_back(std::move(t));
v.emplace_back(MovableNonCopyable());

R>MovableNonCopyable t;
R>v.emplace_back(std::move(t));
R>v.emplace_back(MovableNonCopyable());
R>

MyClass::MyClass() : m_vec(/* как тут инициализировать ???*/) {} // в списке инициализации

func1(func2(Vec(/* как тут инициализировать ???*/))); // в каскаде вызовов

V>Для себя, кроме как создать функцию и там уже сделать emplace_back, и из нее уже вернуть вектор как R-Value, я ничего удобного не нашел

template<class T>
void mov(std::vector<T>& v)
{
}

template<class V, class T, class... Targs>
void mov(V& v, T&& t, Targs&&... args)
{
  v.emplace_back(std::move(t));
  mov(v, args...);
}


template<class T, class... Targs>
std::vector<T> ini(T&& t1, Targs&&... args)
{
  std::vector<T> v;
  mov(v, t1, args...);
  return v;
}
//...
std::vector<MovableNonCopyable> r{ini(MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable())};

V>>Для себя, кроме как создать функцию и там уже сделать emplace_back, и из нее уже вернуть вектор как R-Value, я ничего удобного не нашел

BFE>template<class T>
BFE>void mov(std::vector<T>& v)
BFE>{
BFE>}

BFE>template<class V, class T, class... Targs>
BFE>void mov(V& v, T&& t, Targs&&... args)
BFE>{
BFE>  v.emplace_back(std::move(t));
BFE>  mov(v, args...);
BFE>}


BFE>template<class T, class... Targs>
BFE>std::vector<T> ini(T&& t1, Targs&&... args)
BFE>{
BFE>  std::vector<T> v;
BFE>  mov(v, t1, args...);
BFE>  return v;
BFE>}
BFE>//...
BFE>std::vector<MovableNonCopyable> r{ini(MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable())};
BFE>

#include <iostream>
#include <type_traits>
#include <vector>

struct A
{
  A() { std::cout << "Default" << std::endl; }
  A(A&&) noexcept { std::cout << "Move" << std::endl; }
  A(const A&) { std::cout << "Copy" << std::endl; }
};

template <typename T, typename...U>
std::vector<std::decay_t<T>> make_vector(T&& t, U&&...u)
{
  std::vector<std::decay_t<T>> v;
  v.emplace_back(std::forward<T>(t));
  std::initializer_list<int>{(v.emplace_back(std::forward<U>(u)), 0)...};
  return v;
}

int main()
{
   const A a1;
   A a2;
   auto v = make_vector(A(), a1, std::move(a2));
}

Default
Default
Default
Move
Copy
Move
Move
Move
Move

#include <iostream>
#include <initializer_list>

struct MovableNonCopyable
{
  MovableNonCopyable() {
    std::cout << "1" << std::endl;
  }
  MovableNonCopyable(MovableNonCopyable&&) {
    std::cout << "2" << std::endl;
  }
  MovableNonCopyable& operator=(MovableNonCopyable&&) = default;
  MovableNonCopyable(MovableNonCopyable const &) = delete;
  MovableNonCopyable& operator=(MovableNonCopyable const &) = delete;
};

struct MovableNonCopyableConsumer {
  MovableNonCopyableConsumer(std::initializer_list<MovableNonCopyable> lst) {
    for(const MovableNonCopyable& i : lst) {
    }
  }
};


int main() {
  MovableNonCopyableConsumer v { MovableNonCopyable(), MovableNonCopyable(), MovableNonCopyable() };
}

1
1
1

auto c = {1,2,3,4};

template <class T>
std::vector<T> make_vector(std::initializer_list<T> lst) {
    std::vector<T> result;
    result.reserve(lst.size());
    for(const T& item: lst) {
        T& item2 = const_cast<T&>(item);
        result.emplace_back(std::move(item2));
    }
    return result;
}