Based on [previous question][1] , I have implemented all suggestions. also, i have fixed all unnecessary copies for `std::string` objects in the code.

Is there any thing else can be done to this code?

    #include <iostream>
    #include <string>
    #include <regex>
    #include <cctype>
    #include <limits>
    #include <sstream>
    #include <cassert>
    #include <type_traits>
    
    // C::B : error: 'stoi' is not a member of 'std'!
    int string_to_int(std::string::const_iterator first, 
                      const std::string::const_iterator last)
    {
        int value = 0;
        if(first == last) return value;
    
        const auto sign = *first;
        if (*first == '-' || *first == '+')
            first++;
    
        while (first != last)
        {
            value = value * 10 - (*first++ - '0');
        }
    
        if (sign != '-')
            value = -value;
    
        return value;
    }
    
    int is_RC_type(const std::string& in)
    {
        const auto index = in.find_first_of("C");
        if (index == std::string::npos) return false;
    
        const auto& row = in.substr(1, index - 1);
        const auto& col = in.substr(index + 1);
    
        static const int Min = 1;
        static const int Max = 999999;
        static const std::regex RC{"^R[0-9]+C[0-9]+$"};
    
        const auto colVal = string_to_int(col.cbegin(), col.cend());
        const auto rowVal = string_to_int(row.cbegin(), row.cend());
    
        return  col[0] != '0'
             && row[0] != '0'
             && rowVal >= Min
             && rowVal <= Max
             && colVal >= Min
             && colVal <= Max
             && std::regex_match(in, RC);
    }
    
    bool is_Cell_type(const std::string& in)
    {
        const auto index = in.find_first_of("0123456789");
        if (index == std::string::npos) return false;
    
        const auto& row = in.substr(0, index);
        const auto& col = in.substr(index);
    
        static const int CMin = 1;
        static const int CMax = 999999;
    
        static const std::string AlphaMin{"A"};
        static const std::string AlphaMax{"BDWGM"};
        static const std::regex Cell{"^[A-Z]+[0-9]+$"};
    
        static const auto RMin = string_to_int(AlphaMin.cbegin(), AlphaMin.cend());
        static const auto RMax = string_to_int(AlphaMax.cbegin(), AlphaMax.cend());
    
        const auto colVal = string_to_int(col.cbegin(), col.cend());
        const auto rowVal = string_to_int(row.cbegin(), row.cend());
    
        return col[0] != '0'
            && colVal >= CMin
            && colVal <= CMax
            && rowVal >= RMin
            && rowVal <= RMax
            && std::regex_match(in, Cell);
    }
    
    template <typename Input, typename Prompt, typename Handle>
    Input read_input_impt(Prompt&& prompt, Handle&& handle_input, 
                          std::istream& is = std::cin, std::ostream& os = std::cout)
    {
        Input input{};
        bool is_not_valid = false;
        static const std::string Error{"Not valid input.\n"};
    
        do
        {
            os << std::forward<Prompt>(prompt) << std::flush;
    
            is_not_valid = std::forward<Handle>(handle_input)(input, is);
    
            if (is_not_valid)
            {
                os << Error;
            }
    
            is.clear();
            is.ignore(std::cin.rdbuf()->in_avail());
        } while (is_not_valid);
    
        return input;
    }
    
    template <typename Input, typename Prompt>
    std::enable_if_t<std::is_integral<Input>::value && 
    !std::numeric_limits<Input>::is_signed, Input>
    read_input(Prompt&& prompt)
    {
        static auto int_input = [] (auto& in, std::istream& is)
        {
            static const std::regex Numbers("^[1-9]+$");
            std::string s;
            std::getline(is, s);
            std::stringstream stream{s};
            return is.fail()
                || !std::regex_match(stream.str(), Numbers)
                || !(stream >> in)
                || (1 < in && in > 100000);
        };
    
       return read_input_impt<Input>(std::forward<Prompt>(prompt), int_input);
    }
    
    template <typename Input, typename Prompt>
    std::enable_if_t<std::is_same<std::decay_t<Input>, std::string>::value, Input>
    read_input(Prompt&& prompt)
    {
        static auto string_input = [] (auto& in, std::istream& is)
        {
            std::getline(is, in);
            return  is.fail() || !(is_Cell_type(in) != is_RC_type(in));
        };
    
        return read_input_impt<Input>(std::forward<Prompt>(prompt), string_input);
    }
    
    int main()
    {
        auto n = read_input<unsigned int>("Enter a number of entries: ");
    
        std::cout << "\n\n\tWelcome\n\n";
    
        do
        {
            const auto& word = read_input<std::string>("Enter your choice: ");
    
            if (is_RC_type(word))
            {
                const auto index = word.find_first_of("C");
                assert(index != std::string::npos);
                const auto& row = word.substr(1, index - 1);
                const auto& col = word.substr(index + 1);
    
                auto c = string_to_int(col.cbegin(), col.cend());
                std::string result;
    
                do
                    result =  static_cast<char>('A' + c % 26 - 1) + result;
                while (c /= 26);
    
                std::cout << "\n\nResult: " << result << row << "\n\n";
            }
            else
            {
                const auto index = word.find_first_of("0123456789");
                assert(index != std::string::npos);
                const auto& row = word.substr(index);
                const auto& col = word.substr(0, index);
                int c = 0;
                for (const auto& ch : col)
                {
                    c = 26 * c + (ch - 'A' + 1);
                }
    
                std::cout << "\n\nResult: R" << row << "C" << c << "\n\n";
            }
        } while (--n);
    }


  [1]: https://codereview.stackexchange.com/questions/132774/spreadsheets-keys-converter