Is there any obvious flaw in using sharing without a destination?

Question

I used (for training purposes) the function of the bubble sort template:

template<typename iterInput,
         typename predicate>
void BubbleSort(iterInput first1,iterInput last1,predicate func)
{
    bool swapped(false);
    do
    {
        swapped = false;
        iterInput begin = first1;
        iterInput beginMinus = first1;
        ++begin;
        for (;begin != last1; begin++,beginMinus++)
        {
            if (func(*beginMinus,*begin) )
            {
                std::swap(*beginMinus,*begin);
                swapped = true;
            }
        }
    }
    while(swapped);
}

When I realized that this function would not work for a class without an assignment operator, like this (forgive me for the bad name):

class NoCopyable
{
public:
    explicit NoCopyable(int value) : value_(value) {}
    NoCopyable(const NoCopyable& other) : value_(other.value_) {}
    ~NoCopyable() {}
    bool operator<(const NoCopyable& other) { return value_ < other.value_; }
    void setValue(int value) { value_ = value; }
    std::ostream& print(std::ostream& os) const { return os << value_; }
private:
    NoCopyable& operator=(const NoCopyable& other);
    int value_;
};

std::ostream& operator<<(std::ostream& os, const NoCopyable& obj)
{
    return obj.print(os);
}

struct PrintNoCopyable
{
    void operator()(const NoCopyable& noCopyable) { std::cout << noCopyable << '\n'; }
};

The compiler causes this error. Error C2248 error 1: "NoCopyable :: operator =": cannot access the private member declared in the class "NoCopyable"

So, I changed the code a bit, using my version of the swap function instead of the std :: swap function, here is the code:

template<typename T1,
         typename T2>
void noAssignmentSwap(T1& t1,T2& t2)
{
    T1 temp(t1);
    t1.~T1();
    new (&t1) T1(t2);
    t2.~T2();
    new (&t2) T2(temp);
}

. , , . , , . , T1 T2 . , .

?

Answer 1

, , .

, ! , , , .

Answer 2

, , , , . , , , , .

, , , . ?

#include <vector>
using namespace std;

struct A {
    private:
        void operator=( const A &);
};

int main() {
    vector <A> v;
    v.push_back( A() );
    v[0] = A();     // assignment needed here
}

, .

Answer 3

ctor , , , , , . IOW, , , , .

xor-swap: , .

Answer 4

.