C ++ 11 emplace_back vektörü <yapı>?

Aşağıdaki programı düşünün:

#include <string>
#include <vector>

using namespace std;

struct T
{
    int a;
    double b;
    string c;
};

vector<T> V;

int main()
{
    V.emplace_back(42, 3.14, "foo");
}

Çalışmıyor:

$ g++ -std=gnu++11 ./test.cpp
In file included from /usr/include/c++/4.7/x86_64-linux-gnu/bits/c++allocator.h:34:0,
                 from /usr/include/c++/4.7/bits/allocator.h:48,
                 from /usr/include/c++/4.7/string:43,
                 from ./test.cpp:1:
/usr/include/c++/4.7/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = T; _Args = {int, double, const char (&)[4]}; _Tp = T]’:
/usr/include/c++/4.7/bits/alloc_traits.h:253:4:   required from ‘static typename std::enable_if<std::allocator_traits<_Alloc>::__construct_helper<_Tp, _Args>::value, void>::type std::allocator_traits<_Alloc>::_S_construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = T; _Args = {int, double, const char (&)[4]}; _Alloc = std::allocator<T>; typename std::enable_if<std::allocator_traits<_Alloc>::__construct_helper<_Tp, _Args>::value, void>::type = void]’
/usr/include/c++/4.7/bits/alloc_traits.h:390:4:   required from ‘static void std::allocator_traits<_Alloc>::construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = T; _Args = {int, double, const char (&)[4]}; _Alloc = std::allocator<T>]’
/usr/include/c++/4.7/bits/vector.tcc:97:6:   required from ‘void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {int, double, const char (&)[4]}; _Tp = T; _Alloc = std::allocator<T>]’
./test.cpp:17:32:   required from here
/usr/include/c++/4.7/ext/new_allocator.h:110:4: error: no matching function for call to ‘T::T(int, double, const char [4])’
/usr/include/c++/4.7/ext/new_allocator.h:110:4: note: candidates are:
./test.cpp:6:8: note: T::T()
./test.cpp:6:8: note:   candidate expects 0 arguments, 3 provided
./test.cpp:6:8: note: T::T(const T&)
./test.cpp:6:8: note:   candidate expects 1 argument, 3 provided
./test.cpp:6:8: note: T::T(T&&)
./test.cpp:6:8: note:   candidate expects 1 argument, 3 provided

Bunu yapmanın doğru yolu nedir ve neden?

(Ayrıca tek ve çift diş telleri denendi)

Gelecekten olanlar için, bu davranış değişecektir içinde C ++ 20 .

Başka bir deyişle, dahili olarak uygulama yine de çağıracak T(arg0, arg1, ...)olsa da T{arg0, arg1, ...}, beklediğiniz normal olarak kabul edilecektir .

Sınıf için açıkça bir ctor tanımlamanız gerekir:

#include <string>
#include <vector>

using namespace std;

struct T
{
    int a;
    double b;
    string c;

    T(int a, double b, string &&c) 
        : a(a)
        , b(b)
        , c(std::move(c)) 
    {}
};

vector<T> V;

int main()
{
    V.emplace_back(42, 3.14, "foo");
}

Kullanım emplace_backamacı, daha sonra hedefe kopyalanan (veya taşınan) geçici bir nesne oluşturmaktan kaçınmaktır. Geçici bir nesne yaratmak ve sonra emplace_backonu geçmek de mümkün olsa da, amacı (en azından çoğunu) bozar. Yapmak istediğiniz şey, bağımsız argümanlar iletmek, ardından emplace_backnesneyi yerinde oluşturmak için ctor'u bu argümanlarla çağırmaktır.

Elbette bu bir cevap değil, ancak tuple'ların ilginç bir özelliğini gösteriyor:

#include <string>
#include <tuple>
#include <vector>

using namespace std;

using T = tuple <
    int,
    double,
    string
>;

vector<T> V;

int main()
{
    V.emplace_back(42, 3.14, "foo");
}

Bir kurucu eklemek istemiyorsanız (veya ekleyemiyorsanız), T için ayırıcıyı özelleştirin (veya kendi ayırıcınızı oluşturun).

namespace std {
    template<>
    struct allocator<T> {
        typedef T value_type;
        value_type* allocate(size_t n) { return static_cast<value_type*>(::operator new(sizeof(value_type) * n)); }
        void deallocate(value_type* p, size_t n) { return ::operator delete(static_cast<void*>(p)); }
        template<class U, class... Args>
        void construct(U* p, Args&&... args) { ::new(static_cast<void*>(p)) U{ std::forward<Args>(args)... }; }
    };
}

Not: Yukarıda gösterilen üye işlevi yapısı clang 3.1 ile derlenemez (Üzgünüm, nedenini bilmiyorum). Clang 3.1 (veya başka nedenlerle) kullanacaksanız bir sonrakini deneyin.

void construct(T* p, int a, double b, const string& c) { ::new(static_cast<void*>(p)) T{ a, b, c }; }

Bu, 23.2.1 / 13'te ele alınmış gibi görünüyor.

İlk olarak tanımlar:

A ile özdeş bir ayırıcı_tipi ve T ile özdeş bir değer_tipi olan ve A tipinde bir m değeri, T tipi bir p işaretçisi, T tipinde bir v ifadesi ve T tipi bir r değeri rv verildiğinde, X tipi bir konteyner verildiğinde, aşağıdaki terimler tanımlanmıştır.

Şimdi, onu yerleştirilebilir kılan şey:

T, sıfır veya daha fazla bağımsız değişken için args'den X'e EmplaceConstructible'dır, aşağıdaki ifadenin iyi biçimlendirildiği anlamına gelir: allocator_traits :: construct (m, p, args);

Ve son olarak, yapı çağrısının varsayılan uygulaması hakkında bir not:

Not: Bir konteyner, args kullanarak p'de bir eleman oluşturmak için allocator_traits :: construct (m, p, args) 'ı çağırır. Std :: allocator'daki varsayılan yapı :: new ((void *) p) T (args) 'ı çağıracaktır, ancak özel ayırıcılar farklı bir tanım seçebilir.

Bu bize, bir varsayılan (ve potansiyel olarak tek) ayırıcı şeması için, bir konteynere yerleştirmeye-inşa etmeye çalıştığınız şey için uygun sayıda argümana sahip bir kurucu tanımlamış olmanız gerektiğini söyler.

türünüz için bir yapıcı tanımlamalısınız Tçünkü birstd::string önemsiz olmayan .

dahası, hareket ctor / atama tanımlaması (olası varsayılan) daha iyi olacaktır (çünkü std::stringüye olarak taşınabilir bir üyeye sahipsiniz ) - bu,T çok daha verimli ...

veya neighboug yanıtında önerildiği gibi sadece T{...}aşırı yüklü çağrı için kullanın emplace_back()... her şey tipik kullanım durumlarınıza bağlıdır ...

Örneği oluşturabilir struct Tve ardından vektöre taşıyabilirsiniz:

V.push_back(std::move(T {42, 3.14, "foo"}));

{}Yeni öğeyi başlatmak için sözdizimini kullanabilirsiniz :

V.emplace_back(T{42, 3.14, "foo"});

Bu optimize edilmiş olabilir veya olmayabilir, ancak olması gerekir.

Bunun çalışması için bir kurucu tanımlamalısınız, kodunuzla şunları bile yapamayacağınızı unutmayın:

T a(42, 3.14, "foo");

Ama işe yerleştirmek için ihtiyacın olan şey bu.

bu yüzden sadece:

struct T { 
  ...
  T(int a_, double b_, string c_) a(a_), b(b_), c(c_) {}
}

istenilen şekilde çalışmasını sağlayacaktır.