最大子数组问题

class Tuple
    {
    public:
        int low, high, sum;
        Tuple(int l = 0, int h = 0, int s = 0):low(l), high(h), sum(s) { }
    };

std::vector<int> m_array;

#include <iostream>
#include <vector>
#include <cassert>
#include <fstream>

using namespace std;

namespace nsp_subarray
{
    class Tuple
    {
    public:
        int low, high, sum;
        Tuple(int l = 0, int h = 0, int s = 0):low(l), high(h), sum(s) { }
    };

    class SubArray
    {
    private:
         std::vector<int> m_array;
    public: 
        SubArray() { m_array.clear(); }

        virtual ~SubArray(){}

        void init_data(string fileName)
        {
            ifstream in(fileName.c_str());
            while(!in.eof())
            {
                int e = 0;
                in >> e;
                m_array.push_back(e);
            }
        }

        inline int get_array_size() { return m_array.size(); }

        Tuple find_max_crossing_subarray(int low, int mid, int high)
        {
            int m_leftSum = INT_MIN;
            int m_rightSum = INT_MIN;

            int m_maxLeft = mid;
            int m_maxRight = mid + 1;

            int sum = 0;

            for (int i = mid; i >= low; i--)
            {
                sum += m_array[i];
                if (sum > m_leftSum)
                {
                    m_leftSum = sum;
                    m_maxLeft = i;
                }
            }
            
            sum = 0;
            for (int i = mid + 1; i <= high; i++)
            {
                sum += m_array[i];
                if (sum > m_rightSum)
                {
                    m_rightSum = sum;
                    m_maxRight = i;
                }
            }

            return Tuple(m_maxLeft, m_maxRight, m_leftSum + m_rightSum);
        }

        Tuple find_maximum_subarray(int low, int high)
        {
            if (low == high)
            {
                return Tuple(low, high, m_array[low]);
            } 
            else if (low < high)
            {
                int mid = (low + high) / 2.0;
                Tuple tLeft = find_maximum_subarray(low, mid);

                Tuple tRight = find_maximum_subarray(mid + 1, high);

                Tuple tCross = find_max_crossing_subarray(low, mid, high);

                if (tLeft.sum >= tRight.sum && tLeft.sum >= tCross.sum)
                {
                    return tLeft;
                } 
                else if (tRight.sum >= tLeft.sum && tRight.sum >= tCross.sum)
                {
                    return tRight;
                }
                else
                {
                    return tCross;
                }
            }
        }
    };
};

#include<iostream>
#include "calc_max_subarray.h"

using namespace std;
using namespace nsp_subarray;

int main()
{
    SubArray a;
    Tuple t;

    a.init_data("A.txt");

    t = a.find_maximum_subarray(0, a.get_array_size() - 1);

    return 0;
}