Object on heap gets deleted right after creation - c++

Question

I'm writing a Vector class for my uni the task is to create a method that mutates the elements of this "vector" class into an object of the class itself and returns this object.
My problem is that as soon as I create the Object I should return it gets deleted from the heap.
I create a new Object from the class itself with new DynArray{} and push back the nonmutated elements into the Object. The problem is that before I even can use the Object (push the elements into the "Vector") it got deleted and is not present anymore. Therefore the program crashes. How can I avoid that from happening?
The mutation should take place in the method transform.
header file:
#ifndef DYNARRAY_H
#define DYNARRAY_H
#include <array>
#include <exception>
#include <iostream>
#include <functional>
class DynArray
{
public:
DynArray();
DynArray(int c);
DynArray(DynArray& copyArr);
~DynArray();
int& at(const int i);
int size();
int capacity();
void print();
void push_back(const int value);
void pop_back();
void erase(const int index);
void apply(std::function<void(int&)> f);
DynArray transform(std::function<int(int)> f);
void sort();
void sort(std::function<bool(int,int)> comp);
private:
int _capacity;
int _size;
int * arr = nullptr;
};
#endif // DYNARRAY_H
class file:
#include <dynarray.h>
DynArray::DynArray(){
DynArray(4);
}
DynArray::DynArray(int c) : _capacity{c+=c}, _size{0} {
arr = new int[_capacity];
}
DynArray::DynArray(DynArray& copyArr) : _capacity{copyArr.capacity()}, _size{copyArr.size()}{
arr = new int[_capacity];
for(int i = 0; i < copyArr.size(); i++)
arr[i] = copyArr.at(i);
}
DynArray::~DynArray(){
delete [] arr;
}
...
int& DynArray::at(const int i){
if( i >= 0 && i <= size() && size() > 0)
return arr[i];
else
throw std::invalid_argument("illegal Index");
}
int DynArray::size(){
return _size;
}
int DynArray::capacity(){
return _capacity;
}
...
void DynArray::push_back(const int value){
if(size() >=capacity()){
int * tmp = arr;
_capacity+=_capacity;
arr = new int[_capacity];
for(int i = 0; i < size(); i++){
arr[i] = tmp[i];
}
delete [] tmp;
tmp = nullptr;
arr[size()] = value;
_size++;
}else{
arr[size()] = value;
_size++;
}
}
void DynArray::pop_back(){
if(size() == 0)
throw std::runtime_error("Cant delete a non existing element");
else{
at(size()-1) = 0;
_size--;
}
}
void DynArray::erase(const int index){
if( index >= 0 && index < size() && size() > 0){
for(int i = index; i < (size()-1); i++){
arr[i] = arr[i+1];
}
_size--;
}else{
throw std::invalid_argument("illegal Index");}
}
...
DynArray DynArray::transform(std::function<int(int)> f){
DynArray * copyArr = new DynArray();
for(int i = 0; i < size()-1; i++)
copyArr->push_back(at(i));
for(int i = 0; i < copyArr->size()-1; i++)
f(copyArr->at(i));
return *copyArr;
}
main:
int main()
{
DynArray a(1);
a.push_back(1);
a.push_back(3);
a.push_back(44);
a.push_back(677);
a.push_back(23423);
a.push_back(312);
a.push_back(5645);
a.push_back(5645);
a.push_back(5213145);
a.push_back(561234785);
a.push_back(5675467);
a.print();
std::cout << std::endl;
a.pop_back();
a.pop_back();
a.print();
std::cout << std::endl;
a.erase(5);
a.erase(0);
a.print();
std::cout << std::endl;
DynArray bb;
bb = a.transform(addOne);
bb.print();
std::cout << std::endl;
}
Changed the default and copy constructor as suggested:
DynArray::DynArray() : _capacity{4}, _size{0}{}
...
DynArray::DynArray(const DynArray& copyArr) : _capacity{copyArr._capacity}, _size{copyArr._size}{
arr = new int[_capacity];
//createNewArray(_capacity);
for(int i = 0; i < _size; i++)
arr[i] = copyArr.arr[i];
}