О перевыделении памяти для массива объектов

int *mas = new int[10];
for(int i = 0; i < 10; i++)
{
    mas[i] = i;
}
for(int i = 0; i < 10; i++)
{
    cout << mas[i] << " ";
}
 
mas = new int[20]; //пытаюсь увеличить размерность
 
for(int i = 0; i < 10; i++)
{
    cout << mas[i] << " ";
}

int *mas = new int[10];
for(int i = 0; i < 10; i++)
{
    mas[i] = i;
}
 
for(int i = 0; i < 10; i++)
{
    cout << mas[i] << " ";
}
cout << endl; 
 
int *mas2 = new int[20]; 
 
for(int i = 0; i < 10; i++)
{
    mas2[i] = mas[i];
}
 
delete [] mas;
mas = mas2;
 
for (int i = 10; i < 20; ++i)
{
    mas[i] = i;
}
 
for(int i = 0; i < 20; i++)
{
    cout << mas[i] << " ";
}
 
delete [] mas;

#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>
 
static int default_constructed = 0;
static int constructed = 0;
static int copied = 0;
static int moved = 0;
static int destroyed = 0;
 
struct Foo
{
    std::string attr1;
    std::vector<int> attr2;
 
    Foo() : attr1(), attr2() { ++default_constructed; }
 
    Foo(const std::string &str,
        const std::vector<int> &v) :
            attr1(str), attr2(v) { ++constructed; }
 
    Foo(Foo &&x) :
            attr1( std::move(x.attr1) ),
            attr2( std::move(x.attr2) ) { ++moved; }
 
    Foo(const Foo &x) : Foo(x.attr1, x.attr2) { ++copied; }
 
    ~Foo() { ++destroyed; }
};
 
int main()
{
    std::allocator<Foo> alloc;
 
    // выделим место под 100 объектов Foo
    Foo *array100 = alloc.allocate(100);
 
    // запишем кол-во
    size_t size = 100;
 
    // и сконструируем столько же
    std::uninitialized_fill( array100,
                             array100 + size,
                             Foo("string", {1000, 42}) ); // constructed = 1 (ref)
                                                          // copy constructed = 100
                                                          // destroyed = 1
 
    // увеличим место - 1000
    Foo *array1000 = alloc.allocate(1000);
    size_t new_size = 1000;
 
    // объекты array100 нужно переместить в новое место
    // если тип обладает перемещающим конструктором, то будет использован именно он
    std::uninitialized_copy( std::make_move_iterator(array100),
                             std::make_move_iterator(array100 + size),
                             array1000 ); // move constructed = 100
 
    // инициализируем остальные 900 элементов
    std::uninitialized_fill( array1000 + size,
                             array1000 + new_size,
                             Foo("string v2", {1000, 87}) ); // constructed = 1 (ref)
                                                             // copy constructed = 900
                                                             // destroyed = 1
 
    // объекты array100 больше не валидны
    std::for_each(array100, array100 + size, [&alloc](Foo &x) { x.~Foo(); } );
                                                            // destroyed = 100
 
    // освободим место под array100
    alloc.deallocate(array100, size);
    array100 = nullptr;
 
    // обновим размер
    size = new_size;
 
    // array1000 больше не нужен
    // уничтожим объекты
    std::for_each(array1000, array1000 + size, [&alloc](Foo &x) { x.~Foo(); } );
                                                            //destroyed = 1000
 
    // освободим память
    alloc.deallocate(array1000, size);
 
    // перестраховка
    array1000 = nullptr;
 
    std::cout << "Objects default constructed = " << default_constructed
              << "\nObjects constructed = " << constructed
              << "\nObjects copy constructed = " << copied
              << "\nObjects move constructed = " << moved
              << "\nObjects destroyed = " << destroyed;
 
    return 0;
}

class CArray
{
private:
    SomeClass* arr;
    size_t size;
    CArray() : size(10)
    {
        arr = new SomeClass[10];
    }
    //...
}

class SomeClass
{
    int* smth;
    SomeClass()
    {
        smth = new int[20];
    }
    //...
    ~SomeClass()
    {
        delete[] smth;
    }
}

void CArray::resize(size_t new_size)
{
    SomeClass* temp = new SomeClass[new_size];
    memcpy(temp, this->arr; sizeof(SomeClass) * new_size); // ??? не уверен что так хорошо делать
    delete[] arr;
}

void CArray::resize(size_t new_size)
{
    SomeClass* temp = new SomeClass[new_size];
    size=std::min(size, new_size);
//memcpy(temp, this->arr; sizeof(SomeClass) * new_size); // !!! уверен, так нельзя делать
    std::copy(arr, arr+size, temp); 
/*альтернативный вариант тоже корректно работает, если оператор = корректно перегружен
    for (size_t i=0; i<size; i++)
        temp[i]=arr[i];
*/
    delete[] arr;
    arr=temp;
}