Mam klasę podobną do kontenera, którą chciałbym przenieść tylko wtedy, gdy typ bazowy jest tylko przenoszeniem, ale można go skopiować. Aby dokonać rzeczy proste, załóżmy copyability jest określona przez pojedynczy parametr szablonu bool:Dodaj konstruktora kopii na podstawie parametrów szablonu
template<bool IsCopyable>
struct Foo
{
Foo();
Foo(const Foo&); // only include this when IsCopyable is true
Foo(Foo&&);
Foo& operator=(const Foo&); // only when IsCopyable
Foo& operator=(Foo&&);
};
Teraz, nie mogę po prostu SFINAE konstruktor kopia dala, bo to wymaga zarówno na matrycy i matrycy funkcja nie może być kopią ctor. Ponadto, nie mogę po prostu zrobić static_assert() wewnątrz ctor kopii. Wprawdzie złapie to błędne zastosowanie procedury ctor, ale powoduje również, że klasa z natury kopiuje się z zewnątrz (cecha typu std::is_copy_constructible przyniesie wartość true). Nawiasem mówiąc, niefortunnym wymogiem jest to, że musi on zostać skompilowany w VC++ 2012, więc nie mogę użyć fantazyjnego wyrażenia SFINAE, dziedziczącego ctors, domyślnie/usuniętych funkcji lub constexpr if (niemniej jednak, jeśli masz zgrabne rozwiązanie dla C++ 17 Nadal chciałbym to usłyszeć :))
Oczywistą metodą jest użycie specjalizacji szablonów. Wolałbym nie iść tą drogą, ponieważ w rzeczywistości Foo ma całkiem sporo funkcji i nie lubię się powtarzać. Niemniej jednak, wydaje się to moją jedyną opcję, a może zaimplementować dzielenie niektóre kodu przy użyciu klasy bazowej, tak jak poniżej:
// Base functionality
template<bool IsCopyable>
struct FooBase
{
FooBase();
// move ctor and assignment can go here
FooBase(FooBase&&);
FooBase& operator=(FooBase&&);
// some generic conversion ctor and assignment that I happen to need
template<class T> FooBase(T&& t);
template<class T> FooBase& operator=(T&&);
// ... all sorts of functionality and datamembers
};
// Foo<false>
template<bool IsCopyable>
struct Foo : FooBase<IsCopyable>
{
// can't use inheriting ctors in VS 2012, wrap the calls manually:
Foo() { }
Foo(Foo&& other) : FooBase<IsCopyable>(std::move(other)) { }
Foo& operator=(Foo&& other)
{
FooBase<IsCopyable>::operator=(std::move(other));
return *this;
}
template<class T> Foo(T&& t) : FooBase<IsCopyable>(std::forward<T>(t)) { }
template<class T> Foo& operator=(T&& t)
{
FooBase<IsCopyable>::operator=(std::forward<T>(t));
return *this;
}
};
// Foo<true>
template<>
struct Foo<true> : FooBase<true>
{
// add these
Foo(const Foo&);
Foo& operator=(const Foo&);
// wrapping calls because of VS 2012:
Foo() { }
Foo(Foo&& other) : FooBase<true>(std::move(other)) { }
Foo& operator=(Foo&& other)
{
FooBase<true>::operator=(std::move(other));
return *this;
}
template<class T> Foo(T&& t) : FooBase<true>(std::forward<T>(t)) { }
template<class T> Foo& operator=(T&& t)
{
FooBase<true>::operator=(std::forward<T>(t));
return *this;
}
};
To wciąż nieco rozwlekły. Na szczęście staje się czystsze, gdy można użyć dziedziczenia cers i domyślnych funkcji. Niemniej jednak miałem nadzieję, że jest prostszy sposób, najlepiej nie używając klasy bazowej.
Wow! Prosty i elegancki. Muszę pamiętać tę sztuczkę. – max66
Świetne rozwiązanie z wyjątkiem tego, że idiom "private method without definition" jest nieaktualny w C++ 11. Te metody zostały wyraźnie usunięte. –
@ArneVogel OP mówi, że nie mogą używać usuniętych funkcji. –