# std::enable_shared_from_this::operator=

From cppreference.com
< cpp‎ | memory‎ | enable shared from this

enable_shared_from_this<T>& operator=( const enable_shared_from_this<T> &obj ); |  | (since C++11)

Does nothing; returns *this.

### Parameters

obj | - | an `enable_shared_from_this` to assign to *this

### Return value

*this

### Exceptions

`noexcept` specification:
noexcept

### Notes

The private std::weak_ptr<T> member is not affected by this assignment operator.

### Example

Note: enable_shared_from_this::operator= is defined as `protected` in order to prevent accidental slicing but allow derived classes to have default assignment operators.

Run this code

    #include <memory>
    #include <iostream>

    class SharedInt : public std::enable_shared_from_this<SharedInt>
    {
    public:
        explicit SharedInt(int n) : mNumber(n) {}
        SharedInt(const SharedInt&) = default;
        SharedInt(SharedInt&&) = default;
        ~SharedInt() = default;

        // Both assignment operators use enable_shared_from_this::operator=
        SharedInt& operator=(const SharedInt&) = default;
        SharedInt& operator=(SharedInt&&) = default;

        int number() const { return mNumber; }

    private:
        int mNumber;
    };

    int main() {
        std::shared_ptr<SharedInt> a = std::make_shared<SharedInt>(2);
        std::shared_ptr<SharedInt> b = std::make_shared<SharedInt>(4);
        *a = *b;

        std::cout << a->number() << std::endl;
    }

Output:

    4

### See also

shared_ptr (C++11) | smart pointer with shared object ownership semantics (class template)

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/memory/enable_shared_from_this/operator%3D&oldid=91429"
Category:

- unconditionally noexcept

Hidden categories:

- Pages with unreviewed unconditional noexcept template
- Pages with unreviewed noexcept template