without unifying assignment operator, C++ (vc++)

Language: Layout:

//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x64

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <iomanip>

// #define UNIFYING_ASSIGNMENT_OPERATOR

struct toy_str
{
    toy_str( const char* cstr ) : sz( std::strlen(cstr) ), contents( new char[sz+1] )
    {
        std::cout << this << " constructor: allocated " << sz+1 << " bytes\n" ;
        std::strcpy( contents, cstr ) ;
        std::cout << this << " constructor: copied " << sz+1 << " characters "
                  << *this << '\n' ;
    }

toy_str( const toy_str& that ) : sz( that.sz ), contents( new char[sz+1] )
    {
        std::cout << this << " copy constructor: allocated " << sz+1 << " bytes\n" ;
        std::strcpy( contents, that.contents ) ;
        std::cout << this << " copy constructor: copied " << sz+1 << " characters "
                  << *this << '\n' ;
    }

toy_str( toy_str&& that ) { swap(that) ; }

#ifdef UNIFYING_ASSIGNMENT_OPERATOR

toy_str& operator= ( toy_str that ) noexcept { return swap(that) ; }

#else

toy_str& operator= ( const toy_str& that )
        {
            if( this != std::addressof(that ) )
            {
                std::cout << "currently allocated: " << sz+1 << " bytes, "
                          << "copy requires: " << that.sz+1 << " bytes\n\n" ;
                // if size of buffer is too small, we need to resize it
                if( sz < that.sz )
                {
                    delete[] contents ;
                    std::cout << this << " copy assignment : deallocated " << sz+1 << " bytes\n" ;
                    contents = new char[that.sz+1] ;
                    std::cout << this << " copy assignment : allocated " << that.sz+1 << " bytes\n" ;
                }

sz = that.sz ;
                std::strcpy( contents, that.contents ) ;
                std::cout << this << " copy assignment: copied " << sz+1 << " characters "
                          << that << '\n' ;
            }
            return *this ;
        }

toy_str& operator= ( toy_str&& that ) noexcept { return swap(that) ; }

#endif // UNIFYING_ASSIGNMENT_OPERATOR

~toy_str()
    {
        delete[] contents ;
        std::cout << this << " destructor: deallocated " << sz+1 << " bytes\n" ;
    }

toy_str& swap( toy_str& that ) noexcept
    {
        std::cout << "swap " << this << ' ' << *this << " with "
                  << std::addressof(that) << ' ' << that << '\n' ;
        using std::swap ;
        swap( sz, that.sz ) ;
        swap( contents, that.contents ) ;
        return *this ;
    }

private:
        std::size_t sz ; // TO DO: add member variable to keep track of reserved space
        char* contents ;

friend std::ostream& operator<< ( std::ostream& stm, const toy_str& str )
    { return stm << std::quoted(str.contents) ; }
};

int main()
{
    toy_str a = "abcdefghijklmnop" ;
    const toy_str b = "01234567890123" ;

std::cout << "\n\n------- copy assignment ------------\n\n" ;

#ifdef UNIFYING_ASSIGNMENT_OPERATOR
        std::cout << "with UNIFYING_ASSIGNMENT_OPERATOR\n\n" ;
    #endif // UNIFYING_ASSIGNMENT_OPERATOR

a = b ; // note that a.sz > b.sz

std::cout << "\n----- end copy assignment ----------\n\n" ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1,97 sec, absolute running time: 0,32 sec, absolute service time: 2,31 sec