shallow vs. deep copy and physical vs logical const, C++ (vc++)

Language: Layout:

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

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

namespace shallow {

struct toy_string {

static constexpr std::size_t N = 5 ;
        char* pstr = new char[N] { 'a', 'b', 'c', 'd', '\0' } ;

void change( const char* cstr ) noexcept { std::strncpy( pstr, cstr, N-1 ) ; }

void dump( const char* name = "" ) const {

std::cout << "toy_string (shallow) " << name << " @ " << this << " pstr: "
                      << (const void*) pstr << " => " << std::quoted(pstr) << '\n' ;
        }
    };

// true if a and b have the same logical state
    bool operator== ( const toy_string& a, const toy_string& b )
    { return std::strcmp( a.pstr, b.pstr ) == 0 ; }

bool operator!= ( const toy_string& a, const toy_string& b ) { return !(a==b) ; }
}

namespace deep {

struct toy_string {

static constexpr std::size_t N = 5 ;
        char* pstr = new char[N] { 'a', 'b', 'c', 'd', '\0' } ;

toy_string() = default ;
        toy_string( const toy_string& that ) : pstr( new char[N]{} ) { change(that.pstr) ; }
        toy_string( toy_string&& that ) noexcept : pstr(nullptr) { swap(that) ; }
        toy_string& operator= ( toy_string that ) noexcept { swap(that) ; return *this ; }
        ~toy_string() { delete[] pstr ; }

void swap( toy_string& that ) noexcept { using std::swap ; swap( pstr, that.pstr) ; }

void change( const char* cstr ) noexcept { std::strncpy( pstr, cstr, N-1 ) ; }

void dump( const char* name = "" ) const {

std::cout << "toy_string (deep) " << name << " @ " << this << " pstr: "
                      << (const void*) pstr << " => " << std::quoted(pstr) << '\n' ;
        }
    };

// true if a and b have the same logical state
    bool operator== ( const toy_string& a, const toy_string& b )
    { return std::strcmp( a.pstr, b.pstr ) == 0 ; }

bool operator!= ( const toy_string& a, const toy_string& b ) { return !(a==b) ; }
}

#define DUMP(desc,x) { std::cout << std::setw(25) << desc << ": " ; (x).dump(#x) ; }

#define CHECK_EQUAL(a,b) ( std::cout << "    " #a " == " #b " ? " << std::boolalpha << (a==b) << "\n\n" )

template < typename T > void test() {

const T const_aaa{} ;
     DUMP( "init", const_aaa ) ;

T mutable_b = const_aaa ;
     DUMP( "copy construct", mutable_b ) ;
     CHECK_EQUAL( const_aaa, mutable_b ) ;

mutable_b.change("**") ;
     DUMP( "after change mutable_b", mutable_b ) ;
     DUMP( "after change mutable_b", const_aaa ) ;
     CHECK_EQUAL( const_aaa, mutable_b ) ;

const T const_ccc{} ;
     DUMP( "init", const_ccc ) ;

mutable_b = const_ccc ;
     DUMP( "after assignment", mutable_b ) ;
     CHECK_EQUAL( const_ccc, mutable_b ) ;

mutable_b.change("!!!") ;
     DUMP( "after change mutable_b", mutable_b ) ;
     DUMP( "after change mutable_b", const_ccc ) ;
     CHECK_EQUAL( const_ccc, mutable_b ) ;
}

int main() {

std::cout << "shallow\n---------\n" ;
    test<shallow::toy_string>() ;

std::cout << "\ndeep\n---------\n" ;
    test<deep::toy_string>() ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 10,2 sec, absolute running time: 0,44 sec, absolute service time: 10,66 sec