public:
	MyMap(const MyMap& mm) : MyString(mm), keyname( /* initialize derived class members */)
	{
		// Do the rest of the copy constructor here...
	}

#include <iostream>
#include <string>
#include <utility>

class Base
{
	// ...
public:
	Base() = default;
	Base(const Base&) = default;
	Base(Base&&) = default;
	Base& operator=(const Base&) = default;
	Base& operator=(Base&&) = default;
	virtual ~Base() = default;
	// ...
};

class Derived : public Base
{
	// ...
public:
	Derived() = default;

	Derived(const Derived& rhs) : Base{ rhs }, derived_{ rhs.derived_ }
	{
		// Do the rest of the copy constructor here...
	}

	// If the move constructor doesn't throw an exception, it should be marked noexcept.
	Derived(Derived&& rhs) noexcept : Base{ std::move(rhs) }, derived_{ std::move(rhs.derived_) }
	{
		// Do the rest of the move constructor here...
	}

	Derived& operator=(const Derived& rhs)
	{
		// The copy assignment operator can gracefully handle self-assignment.
		if (this != &rhs)
		{
			Base::operator=(rhs);
			derived_ = rhs.derived_;
			// Do the rest of the copy assignment operator here...
		}
		return *this;
	}

	// If the move assignment operator doesn't throw an exception, it should be marked noexcept.
	Derived& operator=(Derived&& rhs) noexcept
	{
		// The move assignment operator can gracefully handle self-assignment.
		if (this != &rhs)
		{
			Base::operator=(std::move(rhs));
			derived_ = std::move(rhs.derived_);
			// Do the rest of the move assignment operator here...
		}
		return *this;
	}

	~Derived() override = default;
private:
	std::string derived_;
	// ...
};

int main()
{
	Derived d0, d1, d2;
	Derived d3{ d0 };
	Derived d4{ std::move(d0) };
	d1 = d2;
	d1 = std::move(d2);
	return 0;
}

MyString& operator=(const MyString& ms)
{
    if (this != &ms)
    {
        create(ms.buf_len, ms.characters);
    }
    return *this;
}

bool create(int buf_len, const char* data)
{
    char* new_characters = NULL;
    if (buf_len != 0)
    {
        new_characters = new char[buf_len] {};
    }
    if ((new_characters != NULL) && (data != NULL))
        strncpy(new_characters, data, buf_len);

    release();

    this->buf_len = buf_len;
    this->characters = new_characters;

    return true;
}

float sum[8]={0};

float *sum = static_cast<float*>(aligned_alloc(256, 8*sizeof(float)));

std::unique_ptr<std::string> up1(std::make_unique<std::string>("Good morning"));

// copy construct!
std::unique_ptr<std::string> up2(std::make_unique<std::string>(*up1));
// safe copy construct!
std::unique_ptr<std::string> up3(up1 ? std::make_unique<std::string>(*up1) : nullptr);
// copy assignment!
up2 = std::make_unique<std::string>(*up1);
// safe copy assignment!
up3 = up1 ? std::make_unique<std::string>(*up1) : nullptr;