Локальные переменные или прямое обращение к get-объекта класса?

void Array::operator +(Array value)
{
    int sizeFirst = getSize();
    int sizeSecond = value.getSize();
 
    if(sizeFirst > sizeSecond)
    {
 
    }
    else if(sizeFirst < sizeSecond)
    {
 
    }
    else
    {
 
    }
}

void Array::operator +(Array value)
{
    if(getSize() > value.getSize())
    {
 
    }
    else if(getSize() < value.getSize())
    {
 
    }
    else
    {
 
    }
}

void Array::operator +(Array value)
{
    if(size > value.size)
    {
 
    }
    else if(size < value.size)
    {
 
    }
    else
    {
 
    }
}

auto minimal = std::min(getSize(), value.getSize());

  if (getSize() > value.getSize()) {
     // first
  } else if (getSize() < value.getSize()) {
     // second
  } else {
     // third
  }

void Array::operator+(Array oth) {
  const auto my_size = getSize();
  const auto other_size = oth.getSize();
  if (my_size > other_size) {
    // first
  } else if (my_size < other_size) {
    // second
  } else {
    // third
  }
}

void Array::operator+(const Array &oth) {

Array a, b, c; // допустим инициализированы значениями
 a + b + c; // выдаст ошибку компиляции, поскольку результат a + b = void

Array & Array::operator+(const Array &oth) {

int c = a + b;

Array a, b, c;
a + b;
a + c;

Array operator+(const Array &lhs, const Array &rhs);

void Array::operator +(const Array&value)
{
    //умный компилятор читает поля объекта и сохраняет в регистры процессора. Пригодится
    if(getSize()>value.getSize())
    {
        setSize(getSize()+1);
        //а теперь Угадайка - изменилось value.getSize() или нет?
        //может компилятор доверять регистровой копии value.getSize() или нет?
        //Подсказка - вдруг этот оператор вызвали в форме A+A и &value==this?

struct test
{
    int x;
 
    test():x(0){}
    int direct_method(const test&value);
    int local_variable_method(const test&value);
};

#include"test.h"
int test::direct_method(const test &value)
{
    x+=value.x;
    return value.x;
}
 
int test::local_variable_method(const test &value)
{
    int temp=value.x;
    x+=temp;
    return temp;
}

#include <iostream>
#include"test.h"
 
using namespace std;
 
int main()
{
    test t,t1;
    t.x=1;
    t1.x=2;
    cout<<t.direct_method(t1)<<endl;
    cout<<t.local_variable_method(t1)<<endl;
    cout<<t.x<<endl;
    cout<<t1.x<<endl;
    return 0;
}

//array.h
 
#ifndef ARRAY_H
#define ARRAY_H
 
 
class Array
{
public:
    Array();
    ~Array();
    void setArray(int *, int);
    int *getArray();
    int getSize();
    void clearArray();
    void inputArray();
    void printArray();
    void operator +(Array);
    void createArray();     //не нужно создавать отдельный элемент суммирования, трата времени
private:
    int *array;
    int size;
};
 
#endif // ARRAY_H

//array.cpp
 
#include "stdlib.h"
#include "array.h"
#include "iostream"
#include <ctime>
 
using std::wcout;
using std::cout;
using std::cin;
using std::endl;
 
Array::Array()
{
    array = new int[0];
    size = 0;
}
 
Array::~Array()
{
    if(array)
        delete[] array;
}
 
void Array::setArray(int *_array, int _size)
{
    if(_size <= 0)
    {
        wcout << L"Неверный размер массива!" << endl;
        return;
    }
 
//    int *newArray = new int[_size];
 
//    for(int i = 0; i < _size; i++)
//        newArray[i] = _array[i];
 
    if(getSize() != 0)
        clearArray();
 
    array = _array;
    size = _size;
}
 
int *Array::getArray()
{
    return array;
}
 
int Array::getSize()
{
    return size;
}
 
void Array::clearArray()
{
    delete array;
    size = 0;
}
 
void Array::inputArray()
{
    wcout << L"Введите количество элементов: " << endl;
 
    int _size;
    bool isCorrect = false;
 
    while(!isCorrect)
    {
        cin >> _size;
 
        if(_size > 0)
            isCorrect = !isCorrect;
        else
            wcout << L"Неверный размер!" << endl;
    }
 
    wcout << L"Введите " << _size << L" элемент(ов)" << endl;
 
    int *newArray = new int[_size];
 
    for(int i = 0; i < _size; i++)
        cin >> newArray[i];
 
    setArray(newArray, _size);
//    printArray();
}
 
void Array::printArray()
{
    int _size = getSize();
 
    if(_size <= 0)
    {
        wcout << L"Массив не инициализован!" << endl;
        return;
    }
 
    //wcout << L"Вывод массива: " << endl;
    int *_Array = getArray();
 
    for(int i = 0; i < _size; i++)
    {
        cout << _Array[i] << "\t";
    }
 
    cout << endl;
    //wcout << L"Всего элементов " << _size << endl;
}
 
void Array::operator +(Array value)
{
    int sizeFirst = getSize();
    int *arrayFirst = getArray();
 
    int sizeSecond = value.getSize();
    int *arraySecond = value.getArray();
 
    if(sizeFirst == 0 && sizeSecond > 0)
    {
        setArray(arraySecond, sizeSecond);
    }
    else if(sizeFirst <= sizeSecond)
    {
        int *newLongArray = new int[sizeSecond];
 
        for(int i = 0; i < sizeFirst; i++)
            newLongArray[i] = arrayFirst[i] + arraySecond[i];
 
        for(int i = sizeFirst; i < sizeSecond; i++)
            newLongArray[i] = arraySecond[i];
 
        setArray(newLongArray, sizeSecond);
    }
    else if(sizeFirst > sizeSecond)
    {
        for(int i = 0; i < sizeSecond; i++)
            arrayFirst[i] += arraySecond[i];
    }
}
 
void Array::createArray()
{
    int _size = rand() % 10 + 1;
    int *_array = new int[_size];
 
    for(int i = 0; i < _size; i++)
    {
        _array[i] = rand() % 100;
    }
    setArray(_array, _size);
}

//main.cpp
 
/*
 
1) Создать поток расчёта сложной функции по случайным входным данным.
2) Создать поток вывода результатов расчёта через каждые 3 сек.
3) Синхронизировать потоки.
4) Реализовать операции полного останова потоков, перевода потоков в режим ожидания, запуска потоков.
Дополнительные требования: - потоки работают бесконечно
 
*/
 
#include <iostream>
#include <windows.h>
#include <time.h>
#include "array.h"
 
#define sec 1000
 
using namespace std;
 
HANDLE hThreadFirst, hThreadSecond, hThreadThird, hEvent;
 
struct LIFO
{
    Array *array;
    LIFO *nextPtr;
};
 
typedef LIFO STACKNODE;
typedef STACKNODE *STACKNODEPTR;
 
STACKNODEPTR stuck = NULL;
 
bool isThreadEnable, isThreadPause;
 
void push(Array *value)
{
    STACKNODEPTR newPtr = new STACKNODE;
 
    newPtr->array = value;
    newPtr->nextPtr = stuck;
    stuck = newPtr;
}
 
void pop()
{
    STACKNODEPTR tempPtr;
 
    tempPtr = stuck;
    stuck = stuck->nextPtr;
    tempPtr->array->printArray();
    tempPtr->array->~Array();
    delete tempPtr;
}
 
void out(STACKNODEPTR currentPtr)
{
    while(currentPtr != NULL)
    {
        currentPtr->array->printArray();
        currentPtr = currentPtr->nextPtr;
    }
}
 
void threadFirst(void *)
{
    while(isThreadEnable)
    {
        DWORD isPause = WaitForSingleObject(hEvent, 0);
 
        Sleep(sec/300);
        if(isPause != WAIT_OBJECT_0)
        {
            Sleep(sec / 130);
            Array *newArray = new Array;
 
            newArray->createArray();
            push(newArray);
        }
    }
}
 
void threadSecond(void *)
{
    while(isThreadEnable)
    {
        WaitForSingleObject(hThreadFirst, sec * 3);
 
        DWORD isPause = WaitForSingleObject(hEvent, 0);
 
        if(isPause != WAIT_OBJECT_0)
        {
            wcout << L"-----------------------------------------------------" << endl;
            while(stuck != NULL)
            {
                pop();
            }
       }
    }
}
 
int main()
{
    setlocale(LC_ALL, "rus");
    srand(time(NULL));
    isThreadEnable = true;
    isThreadPause = false;
 
    hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
 
    wcout << L"0. Создание потоков" << endl
          << L"1. Пауза/Запуск" << endl
          << L"-1. Выход из потоков" << endl;
 
    while(1)
    {
        int item;
        cin >> item;
 
        if(item > 0)
        {
            isThreadPause = !isThreadPause;
 
            if(isThreadPause)
            {
                SetEvent(hEvent);
                wcout << L"Внимание! Пауза!" << endl;
            }
            else
                ResetEvent(hEvent);
        }
        else if(item < 0)
        {
            isThreadEnable = false;
 
            WaitForSingleObject(hThreadSecond, sec);
            wcout << L"Из потоков вышли успешно!" << endl;
        }
        else if(item == 0)
        {
            isThreadEnable = false;
 
            WaitForSingleObject(hThreadSecond, sec);
 
            CloseHandle(hThreadFirst);
            CloseHandle(hThreadSecond);
 
            hThreadFirst = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) threadFirst, NULL, 0, NULL);
            hThreadSecond = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) threadSecond, NULL, 0, NULL);
 
            isThreadEnable = true;
            isThreadPause = false;
        }
    }
 
    return 0;
}