Не присваивается значение переменной

#pragma once
#include <iostream>
#include <string>
 
using namespace std;
 
class Product {
public:
    Product(const string& _name, double _mass, double _temp,  double _tempMin, double _tempMax, double _heatCapasity);
    Product();
 
    enum class ProductState { Normal, Overheated, Frostbitten };
 
    void change_status();//метод, который меняет состояние продукта в зависимости от количества переданной энергии
    double getMinTemp() const;
    double getTemp() const;
    double getMaxTemp() const;
    string getName() const;
    ProductState getStatus() const;
    double getMass() const;
    double getHeatCapasity() const;
    void setTemp(double temp); 
 
private:
    string name;
    double mass; // единица измерения: кг.
    double temp; // единица измерения: оС
    double tempMax; // единица измерения: оС
    double tempMin; // единица измерения: оС
    ProductState status;
    double heatCapasity;    //unit: J/(kg*oC)
};

#include "Product.h"
#include "Bag.h"
 
Product::Product(const string& _name, double _mass, double _temp, double _tempMax, double _tempMin, double _heatCapasity) :
    name{ _name } 
{
    if (_mass > 0)
        mass = _mass;
    else
        throw invalid_argument("Некорректное значение массы!!! ");
 
    if (_temp > -273.15)
        temp = _temp;
    else 
        throw invalid_argument("Значение температуры не может быть меньше абсоютного 0 !!! ");
 
    if (_tempMax < _tempMin)
        throw invalid_argument("Значение максимально допустимой температуры продукта не может быть меньше минимальной !!! "); 
    
    if (_tempMax > -273.15)
        tempMax = _tempMax;
    else
        throw invalid_argument("Значение максимально допустимой температуры не может быть меньше абсоютного 0 !!! ");
 
    if (_tempMin > -273.15)
        tempMin = _tempMin;
    else
        throw invalid_argument("Значение минимально допустимой температуры не может быть меньше абсоютного 0 !!! ");
 
    if (_heatCapasity > 0)
        heatCapasity = _heatCapasity;
    else
        throw invalid_argument("Некорректное значение теплоёмкости продукта!!! ");
    
    if (temp < tempMin)
        status = ProductState::Frostbitten;
    else if (temp > tempMax)
        status = ProductState::Overheated;
    else
        status = ProductState::Normal; 
}
 
Product::Product() : name{ '\0' }, mass{ 0 }, temp{ 0 }, tempMax{ 0 }, tempMin{ 0 }, heatCapasity{ 0 }
    {}
 
void Product::change_status() {
    if (temp > tempMax)
        status = ProductState::Overheated;
    else {
        if (temp < tempMin) status = ProductState::Frostbitten;
        else status = ProductState::Normal;
    }
}
 
double Product::getMaxTemp() const {
    return tempMax;
}
 
double Product::getMinTemp() const {
    return tempMin;
}
 
double Product::getTemp() const {
    return temp;
}
 
Product::ProductState Product::getStatus() const {
    return status;
}
 
string Product::getName() const {
    return name;
}
 
 
 
double Product::getMass() const {
    return mass;
}
 
double Product::getHeatCapasity() const {
    return heatCapasity;
}
 
 
void Product::setTemp(double temp) {
    if (temp > -273.15)
        this -> temp = temp;
    else
        throw invalid_argument("Значение максимально допустимой температуры не может быть меньше абсоютного 0 !!! ");
    if (status == ProductState::Normal) // если продукт в нормальном состоянии, то его состояние может испортиться, если продукт уже испорчен, то своё состояние поменять уже не может
        change_status();
}

#pragma once
#include "Product.h"
#include <iostream>
#include <MyContainer.h>  
using namespace std; 
 
class Bag {
public:
    Product operator[](int index) const;
    void addProduct(const Product& product); //метод добавления нового продукта в корзину
    void delProduct(int delNumber); //метод удаления i продукта
    void getInfoProduct(int infoNumber,string arrPrint[]) const; //метод, возращающий массив с информацией о i продукте
    double getMassBag() const; //метод, возращающий массу сумки
    int getCountProduct() const; //метод, возращающий количество продуктов в сумке
    double getTempBag() const; //метод, возращающий текущую температуру в сумке
    void clearBag(); //метод, который удаляет все продукты в сумке
    void setMaxMassBag(double massBag); //метод установки максимальной массы сумки
    double getMaxMassBag() const; //метод возврата максимальной массы сумки
    void listProducts(string namePrint[]); //метод выводящий список продуктов
    double summHCM(); //метод суммы массы и теплоёмкости всех продуктов
    int getCountBadProduct();//метод, возращающий количество испорченных продуктов в сумке
    void delLastProduct(); //метод, удаляющий последний добавленный продукт в сумку
    int testProductStatus(); //метод, возращающий состояние продукта, который мы хотим протестировать, испортится ли он при помещении его в сумку
 
private:
    myContainer <Product> bag; 
    double maxMassBag;
    int countBadProducts = 0;
    double tempBag = 0; 
};

#include "Bag.h"
#include "Product.h"
#include <algorithm>
#include <MyContainer.h>  
 
void Bag::addProduct(const Product& product) {
 
    if (getMassBag() + product.getMass() > getMaxMassBag())
        throw invalid_argument("Превышена максимальная масса, которую выдерживает сумка!");
 
    bag.push_back(product);
    tempBag = tempBag + (product.getHeatCapasity() * product.getMass() * product.getTemp()) / summHCM();
 
    for (int i = 0; i < bag.size(); i++) {
        bag[i].setTemp(tempBag);
    }
}
 
double Bag::summHCM() {
    double sumHCM = 0;
    for (int i = 0; i < bag.size(); i++)
        sumHCM = sumHCM + (bag[i].getHeatCapasity() * bag[i].getMass());
    return sumHCM;
}
 
void Bag::delProduct(int delNumber) {
    if (delNumber < 0 || delNumber >= bag.size())
        throw invalid_argument("Номер продукта не может быть отрицательным или превышать номер последнего продукта в сумке!!! ");
 
    bag.erase(delNumber);
}
 
void Bag::getInfoProduct(int infoNumber, string arrPrint[]) const {
    arrPrint[0] = bag[infoNumber].getName();
    arrPrint[1] = to_string(bag[infoNumber].getMass());
    arrPrint[2] = to_string(bag[infoNumber].getTemp());
    arrPrint[3] = to_string(bag[infoNumber].getMaxTemp());
    arrPrint[4] = to_string(bag[infoNumber].getMinTemp());
    arrPrint[5] = to_string(bag[infoNumber].getHeatCapasity());
 
    Product::ProductState status = bag[infoNumber].getStatus();
    switch (status)
    {
    case Product::ProductState::Normal: arrPrint[6] = "Нормальное";
        break;
    case Product::ProductState::Overheated: arrPrint[6] = "Перегрет";
        break;
    case Product::ProductState::Frostbitten: arrPrint[6] = "Переморожен";
        break;
    }
}
 
int Bag::testProductStatus() {
    int stateProduct;
    Product::ProductState status = bag[bag.size() - 1].getStatus();
    switch (status)
    {
    case Product::ProductState::Normal:stateProduct = 1;
        break;
    case Product::ProductState::Overheated: stateProduct = 2;
        break;
    case Product::ProductState::Frostbitten: stateProduct = 3;
    }
    return stateProduct;
}
 
double Bag::getMassBag() const {
    double massBag = 0;
    for (int i = 0; i < bag.size(); i++)
        massBag += bag[i].getMass();
    return massBag;
}
 
int Bag::getCountProduct() const {
    return bag.size();
}
 
void Bag::setMaxMassBag(double maxMassBag) {
    if (maxMassBag > 0) {
        this->maxMassBag = maxMassBag;
 
    }
    else
        throw invalid_argument("Некорректное значение массы сумки!");
}
 
double Bag::getMaxMassBag() const {
    return maxMassBag;
}
 
void Bag::listProducts(string namePrint[]) {
    for (int i = 0; i < bag.size(); i++)
        namePrint[i] = bag[i].getName();
}
 
double Bag::getTempBag() const {
    return tempBag;
}
 
void Bag::clearBag() {
    bag.clear();
    tempBag = 0;
}
 
int Bag::getCountBadProduct() {
    countBadProducts = 0;
    for (int i = 0; i < bag.size(); i++) {
        if (bag[i].getStatus() != Product::ProductState::Normal)
            countBadProducts++;
    }
    return countBadProducts;
}
 
void Bag::delLastProduct() {
    bag.pop_back();
}

#pragma once
#include <iostream>
using namespace std;
 
template <typename T>
class myContainer
{
public:
    ~myContainer(); 
    int size() const;
    void push_back(const T& test);
    void pop_back();
    void erase(int delNumber);
    void clear();
    bool empty();
    T operator [] (int index) const;
    
private:
    int size_arr = 0;
    T* arr = NULL;
};
 
template <class  T>
 myContainer<T>::~myContainer() {
     delete[] arr; 
}
 
template <class  T>
int myContainer<T>:: size() const {
    return size_arr;
}
 
template <class  T>
void myContainer<T>:: push_back(const T& ob) {
    T* newArray = new T[size() + 1]; 
    for (int i = 0; i < size_arr; i++)
        newArray[i] = arr[i];
    newArray[size_arr] = ob;
    size_arr++;
    delete[] arr;
    arr = newArray;
} 
 
template <class  T>
void myContainer<T>:: pop_back() {
    size_arr--;
    T* newArray = new T[size()];
    for (int i = 0; i < size_arr; i++)
        newArray[i] = arr[i];
    delete[] arr;
    arr = newArray;
}
 
template <class  T>
void myContainer<T>:: erase(int delNumber) {
    T* newArray = new T[size() -  1];
    int i = 0;
    while (i < delNumber) {
        newArray[i] = arr[i];
        i++;
    }
    while (i < size_arr - 1) {
        newArray[i] = arr[i + 1];
        i++;
    }
    size_arr--;
    delete[] arr;
    arr = newArray;
    
}
 
template <class  T>
void myContainer<T>:: clear() {
    size_arr = 0;
    delete[] arr;
    T* newArray = new T[size()];
    arr = newArray;
}
 
template <class  T>
bool myContainer<T>:: empty() {
     return size_arr == 0;
} 
 
template <class  T>
 T myContainer<T>:: operator[] (int index) const {
    return arr[index];
}

int main()
{
    Product inst("name", 90, 30, 120, -120, 2);
    std::cout << inst.getTemp() << std::endl;
    inst.setTemp(40);
    std::cout << inst.getTemp() << std::endl;
 
}

template <class  T>
const & T myContainer<T>:: operator[] (int index) const {
    return arr[index];
}
template <class  T>
 T& myContainer<T>:: operator[] (int index) const {
    return arr[index];
}