Это законный подход для создания локальной переменной в C++

У вас есть утечка памяти в MyClass myLocalObject = new MyClass();, поскольку динамически выделяемый объект используется для преобразования-создания нового myLocalObject (это был почти, но не совсем конструктор копирования), а затем указатель теряется.

Вы также не показали код с использованием вектора, но если он не удаляет указатели внутри, у вас будет больше утечек памяти.

Нет причин иметь почти копирующий конструктор; компилятор предоставил вам лучший настоящий конструктор копирования.

Более быстрый и простой подход состоит в том, чтобы признать, что этот код вообще не нуждается в указателях.

class MyClass
{ 
    public:
    MyClass()
        : _num(), _name()   // initialize is better than assignment
    {
        //_num = 0;
        //_name = "";
    }

    // compiler provides a copy constructor taking const MyClass&
    //MyClass(MyClass* pMyClass)
    //{
    //    _num = pMyClass->_num;
    //    _name = pMyClass->_name;
    //}

    void PrintValues() { std::cout << _name << ":" << _num << std::endl; }
    void SetValues(int number, std::string name)
    {
        _num = number;
        _name = name;
    }

private:
    int _num;
    std::string _name;
};


int main()
{
    std::vector<MyClass> myClassArray;  // not a pointer
    MyClass myLocalObject; // = new MyClass();   // why copy a default instance when you can just default initialize?

    for (int i = 0; i < 3; i++)
    {
        myLocalObject.SetValues(i, "test");  // works just as before
        myClassArray.push_back(/*new MyClass*/(myLocalObject)); // don't need a pointer, vector knows how to copy objects
        // also, this was using the "real" copy-constructor, not the conversion from pointer
    }

    myClassArray[1].PrintValues(); // instead of ->
    // use myClassArray further   
}

для случаев, когда необходим указатель, например полиморфизм, используйте интеллектуальный указатель:

std::vector<std::unique_ptr<MyClass>> myClassArray;  // smart pointer
myClassArray.push_back(make_unique<MyDerivedClass>(stuff));

std::unique_ptr автоматически освободит объект, когда он будет удален из вектора (если вы не переместите его явно), избегая необходимости запоминать delete.

В основном есть 2 способа создания экземпляров объектов классов.

Динамическое размещение (в куче)

MyClass* myLocalObject = new MyClass(); // dynamically allocates memory and assigns memory address to myLocalObject

Пример для вашего цикла:

class MyClass
{
private:
    int _num;
    std::string _name;

public:
    // let's add an additional constuctor having default values
    // that makes it easier later on
    // if parameters are passed, they are used, or the defalt values, if not
    // can call it like MyClass(), MyClass(123), or MyClass(456,"hello")
    // you might want to pass larger data as reference, to avoid copying it
    MyClass(int num=0, std::string name = "some default text")
        : _num(num), _name(name)
    {}
};

std::vector<MyClass*> myClassArray;  // your array of pointers
for (int i = 0; i < 3; i++)
    myClassArray.push_back(new MyClass(i, "test"));

// delete
for (auto& pointerToElement : myClassArray) // get a reference to each element (which is a pointer)
    delete pointerToElement; // delete element (call's destructor if defined)

В этом случае вы должны delete myLocalObject; или вы получите утечку памяти.

Вместо того, чтобы иметь дело с необработанными указателями, особенно новичкам в C++, я рекомендую использовать интеллектуальные указатели, которые занимаются управлением памятью вместо вас.

Автоматическое распределение (по возможности в стеке)

MyClass myLocalObject = MyClass(); // automatically allocates memory and creates myLocalObject Обычно это происходит в стеке (если возможно). Это намного быстрее, и вам не нужно иметь дело с динамическим управлением памятью.

Пример для вашего цикла:

std::vector<MyClass> myClassArray; // now "containg" the memory of objects itself
for (int i = 0; i < 3; i++)
    {
        myClassArray.emplace_back(i, "test"); // we use emplace_back instead to construct instances of type MyClass directly into the array
    }

// no deletion required here
// destructors of each element will be called (if defined) when myClassArray is deleted automatically when out of scope

Есть и другие способы, вроде динамического распределения стека и прочей черной магии, но рекомендуем ориентироваться на «стандарт».

В случае работы с большими объемами данных вы можете использовать std::vector::reserve. В сочетании с автоматическим распределением/распределением стека это помогает значительно ускориться, ограничивая выделение памяти до 1 вообще вместо 1 для каждого элемента.

Надеюсь, это поможет :-)