Задача. Наименьший палиндром

#include <iostream>
#include <cstring>
using namespace std;
bool palindrom(char *number)
{
  int left_index=0, right_index=strlen(number)-1;
  while (left_index<right_index)
  {
    if(number[left_index++]!=number[right_index--])
    {
        return false;
    }
  }
  return true;
    
}
int main()
{
    char number_char[1024];
    int number_int;
    cin>>number_char;
        //convert char to int
    number_int=number_char-'0';
        number_int++;
        //convert int to char
       *number_char=number_int+'0';
        cout<<number_int;
    while (palindrom(number_char)==false)
    {
        number_int=*number_char-'0';
        number_int++;
        *number_char=number_int+'0';
        palindrom(number_char);
    }
    
    cout<<number_char;
    
    return 0;
}

void inc(string& num) {
    int mod = 1; // Остаток, изначально равен 1 потому что мы 1 прибавляем
    for (size_t i = 0; i < num.size(); i++) { // Идем по всем цифрам числа
        int dig = num[i] - '0' + mod; // num[i] - '0' Так мы получаем цифру, а потом остаток прибавляем
        mod = dig / 10; // Изменяем остаток
        num[i] = dig % 10 + '0'; // Записываем цифру нового числа
    }
    if (mod) num += to_string(mod); // Если есть остаток то дописываем его в конец строки(to_string используем чтобы int перевести в string
}

//Натуральное число называется палиндромом, если читается слева направо и справа налево
//одинаково. Вам дано одно натуральное число N, которое состоит из не более
//чем 10^6 цифр. Найдите наименьший палиндром, который строго больше N.
//Формат входного файла.
//В единственной строке входного файла содержится одно натуральное
//число N. N не содержит лидирующих нулей и состоит из не более чем 10^6 цифр.
 
//Пример:
//1)  Ввод: 365
//    Вывод:373;
 
//2)  Ввод: 1
//    Вывод:2;
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
///////////////////////////////////////////////////////////////////////////////
T_str   get_left_s
    (
        T_str   const   &   s,
        size_t              palindrom_len
    )
{
    return  s.substr    (
                            0,
 
                                palindrom_len
                            -   palindrom_len / 2
                        );
}
///////////////////////////////////////////////////////////////////////////////
T_str   get_palindrom
    (
        T_str   const   &   s,
        size_t              palindrom_len
    )
{
    auto    left_s      =   get_left_s  (
                                            s,
                                            palindrom_len
                                        );
 
    auto    right_s     =   left_s.substr   (
                                                0,
 
                                                    palindrom_len
                                                -   left_s.size()
                                            );
 
    if  (
            right_s.size()
        )
    {
        std::reverse
            (
                right_s.begin   (),
                right_s.end     ()
            );
    }//if
 
    return      left_s
            +   right_s;
}
///////////////////////////////////////////////////////////////////////////////
T_str   get_inc( T_str  const   &   s )
{
    auto    res     =   '0' + s;
 
    for (
            auto    rev_it  =   res.rbegin();
            ;
            ++rev_it
        )
    {
        if  (
                *rev_it     <   '9'
            )
        {
            ++*rev_it;
            break;
        }
 
        *rev_it     =   '0';
    }//for
 
    if  (
                res.front()
            ==  '0'
        )
    {
        res.erase(0, 1);
    }
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
T_str   min_of_palindrom_greater_than( T_str    const   &   s )
{
    auto    palindrom_len   (
                                s.size()
                            );
 
    auto    res         =   get_palindrom   (
                                                s,
                                                palindrom_len
                                            );
 
    if  (
            res     <=  s
        )
    {
        auto    left_s      =   get_left_s  (
                                                s,
                                                palindrom_len
                                            );
 
        auto    new_left_s  =   get_inc( left_s );
 
        if  (
                    new_left_s  .size()
                >   left_s      .size()
            )
        {
            ++palindrom_len;
        }
 
        res     =   get_palindrom   (
                                        new_left_s,
                                        palindrom_len
                                    );
    }//if
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        T_str   s;
 
        std::cout   <<  "s = ";
        std::cin    >>  s;
 
        std::cout   <<  min_of_palindrom_greater_than(s)
                    <<  std::endl
                    <<  std::endl;
    }//for
}